source: main/trunk/ibisph-view/src/main/webapp/xslt/html/Page.xslt @ 19868

<?xml version="1.0" encoding="ISO-8859-1"?>

<xsl:stylesheet version="3.0" 
        xmlns:xsl ="http://www.w3.org/1999/XSL/Transform" 
        xmlns:ibis="http://www.ibisph.org"

        exclude-result-prefixes="ibis"
>
        <xsl:import href="../ibis.xslt"/>
        <xsl:import href="ContentContainer.xslt"/>
        <xsl:import href="Help.xslt"/>
        <xsl:import href="SelectionsList.xslt"/>
        <xsl:import href="MenuSelectionsList.xslt"/>


        <ibis:doc>
                <name>html/Page</name>
                <summary>Standard HTML "Page" template API definitions</summary>
                <description>
                        Standard HTML page template definition/API used for ALL IBIS-PH web 
                        page transformations.  This XSLT defines the core XSLT HTML page API.

                        This XSLT is "imported" by the root site specific page.xslt which is 
                        then imported by all sub IBISPH-View XSLTs that produce HTML.  Some
                        of the core HTML "page" templates defined are simply stubbed out 
                        template definitions without any code (which may or may not be 
                        implemented in sub page.xslt template files).  These templates are
                        designed so that they can be overridden as needed either in sub site 
                        specific page template files or in the specific page's template file.

                        CORE XSLT IMPORT NOTE:
                        Prior to 6/2015, tried to have the page.xslt or ss.xslt import the 
                        needed xslts so that it was obvious what was being used.  However,
                        there were duplicate imports and most pages use some if not all of 
                        the main "core" xslt templates.  So, even though they are not called
                        directly in this file they are imported within the core Page.xslt
                        because it is more reliable then importing in the main ss.xslt and
                        then duplicating those imports in sub Page.xslt files.
                        This xslt did not include the 
                </description>
        </ibis:doc>

        <xsl:output method="html" version="5.0" html-version="5" encoding="ISO-8859-1" indent="no"/>
        <!-- 
                IMPORTANT INDENT: off = "no". If yes then wiki formatting is messed.

                Output Notes:
                - method='html', 'text' or 'xhtml'.  If xhtml then version needs to be
                  1.0 or 1.1.  Version 1.1 requires not omitting the xml declaration which 
                  messes with the CSS formatting so for IE, xhtml strict should be 1.0 
                  so can omit the xml declaration.  Even using xhtml 1.0, IE still will
                  NOT format correctly like FF.  If html then version should be 4.01.
                  XHTML works with xalan BUT ie 6 can't handle.  Posts about IE 6.x not 
                  handling xHTML: 
                        http://erik.eae.net/archives/2003/07/29/21.07.24/
                        http://www.objectsbydesign.com/projects/xslt/xhtml.html:
                - The main xhtml item IE has a problem with is the <script/> tag!  If it's 
                  standard like: <script></script> then all appears to work!!!  One trick 
                  is to insert "//" in between the tags or the &#160; character.  That 
                  works!!!  If nothing is put in between (e.g. normal whitespace then it auto 
                  collapses to the xml way of closing tags/elements without any content ("/>").

                - typical encoding="UTF-8" encoding="ISO-8859-1".  Had problems with UTF-8.
                - "omit" controls the xml version tag which messes up most current browsers.
                - Same goes for setting method="xml".  Both produce correct code but ie 
                  doesn't like it.

                Other doctype values:
                doctype-public="-//W3C//DTD HTML 4.01//EN"
                doctype-system="http://www.w3.org/TR/html4/strict.dtd"

                doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"
                doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"

                doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN" 
                doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"

                doctype-system="about:legacy-compat"  -  used for HTML5 for older XSLT processors.

                Complete HTML 4.01:
                method="html" media-type="text/html" version="4.01" indent="no" 
                encoding="ISO-8859-1" omit-xml-declaration="yes"
                doctype-public="-//W3C//DTD HTML 4.01//EN"
                doctype-system="http://www.w3.org/TR/html4/strict.dtd"

                Complete HTML5 with Saxon: 
                method="html" version="5.0" encoding="ISO-8859-1" indent="no"
        -->


        <!-- STRIPPING SPACE: The xsl:strip-space element is used to remove white-space 
                only nodes so that they do not appear in the output (removes the element!).
                The related xsl:preserve-space element is used to keep white-space only 
                nodes in the output. Note that the default is to leave white-space only 
                nodes.  Therefore, it is only necessary to use the xsl:preserve-space 
                element when you use the xsl:strip-space element and wish to insure that 
                certain white-space nodes are not removed.  So, some elements are null 
                text elements and are used as flags and thus MUST not be stripped.  If 
                there are problems then a list of flag type elements must be specified 
                at the top of the xslt.

                See: http://www-106.ibm.com/developerworks/xml/library/x-tipwhitesp.html
        -->




        <!-- ====================================================== GLOBAL VARIABLES
                These are variables which are needed to be defined in one centralized 
                location which are then used by various XSLTs.  Some templates could have
                been implemented as variables and would have made more sense.  However,
                variables are typically only created when an element is used more than
                once or there's a specific reason.  So for element text that is only used
                once a template is typically marginally better as it does not need to be
                stored in memory like a variable is.
        -->
        <xsl:param name="Page.ibisphWebmasterEmailAddress" select="'webmaster@ibis.your_state.gov'"
                ibis:doc="Site's Webmaster email address which is used in the head's meta 
                        tag and can be used in footers etc.  This value should be implemented 
                        in the site specific XSLT."
        />

        <xsl:param name="Page.applicationTitle" select="'IBIS-PH'"
                ibis:doc="Used for the page's title element prefix text"
        />

        <xsl:param name="Page.pageTitle" 
                ibis:doc="Provides the page's title text which is typically displayed 
                        by the browser's window title bar.  This variable is a stubb and 
                        should be implemented for each specific type of page."
        />

        <xsl:param name="Page.contentTitle" select="$Page.pageTitle"
                ibis:doc="Provides the page's content title text which is typically 
                        displayed in the content header section.  This variable is a stubb 
                        and should be implemented for each specific type of page.
                "
        />

        <xsl:param name="Page.metaAuthor" select="'Deparment of Health'"
                ibis:doc="Optional standardized hook template that provides the text to 
                        be inserted into the page's head 'author' meta tag element.
                "
        />

        <xsl:param name="Page.metaDescription" select="$Page.pageTitle"
                ibis:doc="Optional standardized hook template that provides the
                        text to be inserted into the page's head 'description' meta tag element.
                        This template should be overridden in the page specific templates.
                        The value defaults to the text provided by the 'html.pageTitle' template.
                "
        />

        <xsl:param name="Page.metaKeywords" select="$Page.pageTitle"
                ibis:doc="Optional standardized hook template that provides the
                        text to be inserted into the page's head 'keywords' meta tag element.
                        This template should be overridden in the page specific templates.
                        The value defaults to the text provided by the 'html.pageTitle' template.
                "
        />

        <xsl:param name="Page.htmlClass" ibis:doc="Stub param that provides hook to set the main html css class."/>

        <xsl:param name="XMLModifedDate"
                ibis:doc="Parameter which is set via the Java model code so that the 
                        resultant page can display the XML file's modified date/time."
        />
        <xsl:variable name="Page.XMLModifedDate" 
                select="if(string-length($XMLModifedDate) = 0) then //ibis:doc/versions/version[1]/date else $XMLModifedDate"
                ibis:doc="Variable that wraps the 'XMLModifedDate' parameter so that we 
                        know where this variable/parameter is defined.  If the parameter
                        value is not specified then the parameter defaults to selecting the 
                        XML document's ibis:doc version date."
        />

        <xsl:param name="OrgUnits"/>
        <xsl:param name="Page.orgUnits" select="$OrgUnits/ORG_UNITS"
                ibis:doc="Convenience variable which holds the ORG_UNIT elements.  This 
                        could/should be loaded and cached at app startup and injected at some 
                        future point for speed.  For now, because there is not a reload the   
                        cache when published mechanism, it is implemented as a file/document
                        lookup.
                "
        />
        <xsl:param name="Page.orgUnitName" select="'DEFAULT'"
                ibis:doc="Default Org Unit name used for page body content footer.  This 
                variable is overridden by indicator profile and query module pages.
                Defaults to 'DEFAULT'."
        />


        <!-- ============================= ROOT HTML CONTAINER/API CALLING TEMPLATES
                The core templates (API) are listed below.  These templates are defined 
                here as they apply to most of HTML pages that are produced.  Since this 
                XSLT is designed to be imported, these templates can be overridden by 
                more specific XSLT implementations.  Note that these templates all begin 
                with "html.".  This was done so it is easy to identify where these 
                templates are defined and being used/called from.
        -->

        <!-- THE ROOT TEMPLATE -->
        <xsl:template match="/"
                ibis:doc="Main root element processing template.  This template is the
                        main page template API.  This includes the HTML tag, the head information, 
                        and the cotent.
                "
        >
                <!-- global error catcher... -->
                <xsl:fallback>
                        <xsl:message terminate="yes">
                                The XSLT has a problem processing and is now terminating...
                        </xsl:message>
                </xsl:fallback>

                <html lang="en">
                        <xsl:if test="string-length($Page.htmlClass) != 0">
                                <xsl:attribute name="class" select="$Page.htmlClass"/>
                        </xsl:if>

                        <xsl:call-template name="Page.head"/>
                        <xsl:call-template name="Page.body"/>
                </html>
        </xsl:template>


        <!-- =============================================== HTML HEAD API TEMPLATES
                HTML HEAD element templates.  Most of these templates are blank stubs.
                These templates provide an "interface" definition/mechanism where other 
                XSLT pages can implement/add additional functionality by overriding the 
                these defined templates with a site specific or a more page specific 
                XSLT implementation.
        -->
        <xsl:template name="Page.head" ibis:doc="Produces the HTML HEAD element and contents.">
                <head>
                        <meta http-equiv="Reply-to"             content="{$Page.ibisphWebmasterEmailAddress}"/>

                        <meta name="author"      content="{$Page.metaAuthor}"/>
                        <meta name="description" content="{$Page.metaDescription}"/>
                        <meta name="keywords"    content="{$Page.metaKeywords}"/>
                        <meta name="robots"      content="ALL"/>

                        <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
                        <!-- commented for hand held but doesn't work very well
                        <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no"/>
                        <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
                        See more at: http://m5designstudio.com/2013/orlando-web-design/bootstrap-responsive-layout/#sthash.K7Y4tGnk.dpuf
                        https://developer.mozilla.org/en-US/docs/Mozilla/Mobile/Viewport_meta_tag
                        -->

                        <title><xsl:value-of select="if(contains($Page.pageTitle, $Page.applicationTitle))then $Page.pageTitle else concat($Page.applicationTitle, ' - ', $Page.pageTitle)"/></title>

                        <link rel="shortcut icon" href="{$ibis.contextPath}image/application.ico" type="image/vnd.microsoft.icon"/>
                        <link rel="icon"          href="{$ibis.contextPath}image/application.ico" type="image/vnd.microsoft.icon"/> 
                        <link rel="home"          href="{$ibis.contextPath}"/> 
                        <link rel="help"          href="{$ibis.contextPath}about/Help.html"/> 
                        <link rel="toc"           href="{$ibis.contextPath}about/SiteMap.html"/> 
                        <link rel="make"          href="http://www.ibisph.org"/> 

                        <xsl:call-template name="Page.standardCSS"/>
                        <xsl:call-template name="Page.specificCSS"/>

                        <xsl:call-template name="Page.standardScript"/>
                        <xsl:call-template name="Page.specificScript"/>

                        <xsl:call-template name="Page.specificHeadContent"/>
                </head>
        </xsl:template>


        <!-- META TAG CACHING NOTE: Meta tags are easy to use, but aren't very effective. 
                That's because they're only honoured by a few browser caches (which actually 
                read the HTML), not proxy caches (which almost never read the HTML in the 
                document). While it may be tempting to put a Pragma: no-cache meta tag into 
                a Web page, it won't necessarily cause it to be kept fresh.  See:
                http://www.mnot.net/cache_docs/#CONTROL
        -->
        <xsl:template name="Page.metaNoCacheControl"
                ibis:doc="Returns all the HTML HEAD meta tag elements that are 
                        used by a browser/proxy caches to cache content.  This includes:
                        'Expires', 'Pragma', 'Cache-Control', and 'robots'."
        >
                <meta http-equiv="Expires"       content="Fri, 12 Dec 1980 23:23:23 GMT"/>
                <meta http-equiv="Cache-Control" content="no-store, no-cache, must-revalidate, post-check=0, pre-check=0, max-age=0"/>
                <meta http-equiv="Pragma"        content="no-cache"/>
                <meta name="robots"              content="NONE, NOINDEX, NOFOLLOW, NOARCHIVE"/>
        </xsl:template>



        <xsl:template name="Page.standardCSS"
                ibis:doc="Provides the common/standard CSS to be used by all the
                        pages.  It is recommended that this template be defined high up in 
                        the import hierarchy for ease of maintenance e.g. not be overridden 
                        by each specific page type.  The 'html.otherCSS' template is provided
                        to handle lower level, page specific CSS links/code.  The default is 
                        a CSS link to the 'css/stylesheet.css' file.

                        The print version is used IF the PrinterFriendly parameter is present 
                        then the print.css is provided as a generic media type.  If not present 
                        then the media type is set to 'print' so that any browser print operation 
                        will be formatted accordingly.  This unique structure allows for pages 
                        to still be served up as a web page without the header, navigation and 
                        other elements formatted appropriately - which will still work for 
                        printing!  Note that this CSS should be placed after all other CSS 
                        definitions so that it can override previous settings.
                "
        >
                <link rel="stylesheet" type="text/css" href="{$ibis.contextPath}css/stylesheet.css"/>
                <link rel="stylesheet" type="text/css" href="{$ibis.contextPath}css/_print.css">
                        <xsl:if test="ibis:isPrinterFriendly() = false()">
                                <xsl:attribute name="media" select="'print'"/>
                        </xsl:if>
                </link>
                <xsl:if test="($PrinterFriendly = 'bw') or ($PrinterFriendly = 'BW')">
                        <link rel="stylesheet" type="text/css" href="{$ibis.contextPath}css/_print_bw.css" media="print"/>
                </xsl:if>
        </xsl:template>


        <xsl:template name="Page.specificCSS" ibis:doc="Provides a hook for sub page CSS to be implemented."/>


        <xsl:template name="Page.standardScript"
                ibis:doc="Provides the common/standard script code/links to be used 
                        by all the pages.  It is recommended that this template be defined high 
                        up in the import hierarchy for ease of maintenance e.g. not be overridden 
                        by each specific page type.  The 'page.specificScript' template is designed 
                        to handle page specific script links/code.  Note that even though this is
                        a stubbed out API call, a reference is made to the jquery code which 
                        highlights the dependency that most script code has on this core script.

                        404 jquery jquery.min.map file issue:
                        See: http://stackoverflow.com/questions/18365315/jquerys-jquery-1-10-2-min-map-is-triggering-a-404-not-found
                "
        >
                <script src="{$ibis.contextPath}js/jquery.min.js"/>
                <script src="{$ibis.contextPath}js/jquery.wikitohtml.js"/>
                <script src="{$ibis.contextPath}js/kendo.all.min.js"/>
                <script src="{$ibis.contextPath}js/kendo.js"/>

                <script>
                        // <![CDATA[
                        $(document).ready(function()
                        {
                                // Add the wiki processing if any element uses it.  This should 
                                // only be done on non HTML_CONTENT type pages.
// both ways work... $("*[wiki='true']").each( function(){ $(this).wikiToHTML(); } );
                                $("*[wiki='true']").wikiToHTML();
                        }); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ End of Function ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                        // ]]>
                </script>
        </xsl:template>


        <xsl:template name="Page.specificScript" ibis:doc="Provides mechanism for type of page specific script code."/>


        <xsl:template name="Page.specificHeadContent"
                ibis:doc="Optional standardized hook template so that other more 
                        page specific or site specific templates can include other meta tag 
                        elements, CSS, or script code.  The template is a stub and should
                        be implemented for each specific type of page."
        />



        <!-- ================================ HTML PAGE LAYOUT SECTION API TEMPLATES
                These templates provide the basic page layout control.
        -->
        <xsl:template name="Page.body" ibis:doc="Produces the HTML BODY element and contents.">
                <body>
                        <xsl:call-template name="Page.adaMainSectionLinks"/>
                        <xsl:call-template name="Page.banner"/>

                        <div id="page">
                                <xsl:call-template name="Page.header"/>
                                <xsl:call-template name="Page.content"/>
                                <xsl:call-template name="Page.footer"/>
                        </div>
                </body>
        </xsl:template>


        <xsl:template name="Page.adaMainSectionLinks" ibis:doc="Provides ADA recommended section jump tos.">
                <div title="Page's main sections index" class="OffPage">
                        <a href="#siteSearch"        title="Skip to search">Skip directly to search</a>
                        <a href="#siteNavigation"    title="Skip to site navigation">Skip directly to the site navigation</a>
                        <a href="#sectionsContainer" title="Skip to content">Skip directly to the page's main content</a>
                        <a href="?PrinterFriendly=x" title="Show page without navigation menus and headers."/>
                </div>
        </xsl:template>


        <xsl:template name="Page.banner" ibis:doc="Optional stubbed template for state and doh banners."/>


        <xsl:template name="Page.header"
                ibis:doc="This is the page's header content that usually has the 
                        web application's logo and common/major navigation links and options.
                        This is a stubbed hook template that is intended to be overridden in 
                        a site specific template file or left as is which results in this 
                        being effectively turned off."
        >
                <header id="header"/>
        </xsl:template>


        <xsl:template name="Page.content"
                ibis:doc="This template is used to provide the main page content.  It is
                        comprised of a content header, content body, and content footer.
                        Again these can be overridden to provide site specific implementations.
                "
        >
                <main id="content">
                        <xsl:call-template name="Page.contentHeader"/>
                        <xsl:call-template name="Page.contentBody"/>
                        <xsl:call-template name="Page.contentFooter"/>
                </main>
        </xsl:template>


        <xsl:template name="Page.contentHeader"
                ibis:doc="This is the page's content top that defaults to provding the
                        'Page.contentTitle' text within an HTML h1 container.  If the content 
                        title text does not exist, then the nothing is inserted."
        >
                <xsl:if test="string-length($Page.contentTitle) != 0">
                        <header><h1><xsl:value-of select="$Page.contentTitle"/></h1></header>
                </xsl:if>
        </xsl:template>


        <xsl:template name="Page.contentBody"
                ibis:doc="Stubbed template that needs to be implemented in each page specific 
                        XSLT file (not site specific) that provides the main page body content."
        />


        <xsl:template name="Page.contentFooter"
                ibis:doc="This is the page's content bottom that defaults to 
                        provding the 'page.orgUnit' text within an HTML DIV container that has 
                        an id of 'contentFooter'.  If the org unit does not exist, then nothing
                        is displayed."
        >
                <xsl:param name="orgUnitName" select="if(string-length($Page.orgUnitName) != 0) then $Page.orgUnitName else 'DEFAULT'"/>
                <xsl:param name="orgUnit"     select="$Page.orgUnits//ORG_UNIT[NAME=$orgUnitName]"/>

                <xsl:if test="string-length($orgUnit/TITLE) != 0">
                        <footer>
                                <xsl:value-of select="$orgUnit/TITLE"/>, <xsl:value-of select="$orgUnit/CONTACT_TEXT"/>
                                <xsl:if test="string-length($orgUnit/URL) != 0">
                                        (<a href="{$orgUnit/URL}"><xsl:value-of select="$orgUnit/URL"/></a>)
                                </xsl:if>
                        </footer>
                </xsl:if>
        </xsl:template>


        <xsl:template name="Page.footer"
                ibis:doc="This is the page's footer content that usually has the 
                        web application's disclaimers, links etc.  This is a stubbed hook 
                        template that is intended to be overridden in a site specific template 
                        file or left as is which results in this being effectively turned off."
        >
                <footer/>
        </xsl:template>



        <xsl:template name="Page.insertAJAXContent"
                ibis:doc="
                        Provides a way to get AJAX content into a page.
                        1) The main use case is to get HTML_CONTENT to look like it's part of
                                the IP's views.  This use case is for UT EPHT wants some 
                                HTML_CONTENT page to show up as a dataless *view*.  The page will 
                                have to be 100% crafted as HTML_CONTENT and does not provide/allow 
                                any IP or IPV type data field processing etc - all or nothing.  

                        2) Alternate IP view that looks like it's part of the IP's views.
                                This tries to provide a work around for adopters that want IPs 
                                to contain views of different value type e.g. Rates and Counts 
                                to be contained within the same *IP view* set.  This works IF: 
                                A) The *Rates* and *Counts* IP data is duplicated, 
                                B) The map is turned off from the view being referenced.
                                Note that this sometimes doesn't work for maps because the map 
                                layers are AJAX and this surrogate content is also ajax of the 
                                entire page body.

                        NOTES: 
                                Tried IFRAME and EMBED.  If entire page then get header, footer, 
                                nav etc.  If limited to the section.Sections container element 
                                then have issues with css and script.  Also needed script to auto 
                                size the height.  See 9/19/2017 commit for temp IP Interactive.xslt 
                                code tried.

                                Can't easily include outside content.  It's easily done IF we 
                                don't have the security headers enabled - which then raises lots 
                                of flags when the site is scanned for security vulnerabilities.
                "
        >
                <xsl:param name="sourceContentURL"/>
                <xsl:param name="sourceContentJQuerySelector" select="'section.Sections'"/>
                <xsl:param name="destContentJQuerySelector"   select="'section.Sections'"/>

                <script>
                        $.ajax({
                                url: "<xsl:value-of select="ibis:getCompleteURL($sourceContentURL)"/>"
                                ,type: "GET"
                                ,success: function(data)
                                {
                                        $("<xsl:value-of select="$destContentJQuerySelector"/>").html( $(data).find("<xsl:value-of select="$sourceContentJQuerySelector"/>").html() );
                                }
                        });
                </script>
        </xsl:template>

</xsl:stylesheet>
<!-- ============================= End of File ============================= -->