pear_lib_tmp/HTML/Page.php

   1 <?php
   2 /* vim: set expandtab tabstop=4 shiftwidth=4: */
   3 // +----------------------------------------------------------------------+
   4 // | PHP Version 4                                                        |
   5 // +----------------------------------------------------------------------+
   6 // | Copyright (c) 1997 - 2003 The PHP Group                              |
   7 // +----------------------------------------------------------------------+
   8 // | This source file is subject to version 3.0 of the PHP license,       |
   9 // | that is bundled with this package in the file LICENSE, and is        |
  10 // | available at through the world-wide-web at                           |
  11 // | http://www.php.net/license/3_0.txt.                                  |
  12 // | If you did not receive a copy of the PHP license and are unable to   |
  13 // | obtain it through the world-wide-web, please send a note to          |
  14 // | license@php.net so we can mail you a copy immediately.               |
  15 // +----------------------------------------------------------------------+
  16 // | Authors: Adam Daniel <adaniel1@eesus.jnj.com>                        |
  17 // |          Klaus Guenther <klaus@capitalfocus.org>                     |
  18 // +----------------------------------------------------------------------+
  19 //
  20 // $Id$
  21
  22 require_once 'PEAR.php';
  23 require_once 'HTML/Common.php';
  24 // HTML/Page/Doctypes.php is required in _getDoctype()
  25
  26 /**
  27  * Base class for XHTML pages
  28  *
  29  * This class handles the details for creating a properly constructed XHTML page.
  30  * Page caching, stylesheets, client side script, and Meta tags can be
  31  * managed using this class.
  32  *
  33  * The body may be a string, object, or array of objects or strings. Objects with
  34  * toHtml() and toString() methods are supported.
  35  *
  36  *
  37  * XHTML Examples:
  38  * ---------------
  39  *
  40  * Simplest example:
  41  * -----------------
  42  * <code>
  43  * // the default doctype is XHTML 1.0 Transitional
  44  * // All doctypes and defaults are set in HTML/Page/Doctypes.php
  45  * $p = new HTML_Page();
  46  *
  47  * //add some content
  48  * $p->addBodyContent("<p>some text</p>");
  49  *
  50  * // print to browser
  51  * $p->display();
  52  * </code>
  53  *
  54  * Complex XHTML example:
  55  * ----------------------
  56  * <code>
  57  * // The initializing code can also be in in the form of an HTML
  58  * // attr="value" string.
  59  * // Possible attributes are: charset, lineend, tab, doctype, language and cache
  60  *
  61  * $p = new HTML_Page(array (
  62  *
  63  *                          // Sets the charset encoding
  64  *                          // utf-8 is default
  65  *                          'charset'  => 'utf-8',
  66  *
  67  *                          // Sets the line end character
  68  *                          // unix (\n) is default
  69  *                          'lineend'  => 'unix',
  70  *
  71  *                          // Sets the tab string for autoindent
  72  *                          // tab (\t) is default
  73  *                          'tab'  => '  ',
  74  *
  75  *                          // This is where you define the doctype
  76  *                          'doctype'  => "XHTML 1.0 Strict",
  77  *
  78  *                          // Global page language setting
  79  *                          'language' => 'en',
  80  *
  81  *                          // If cache is set to true, the browser may
  82  *                          // cache the output. Else
  83  *                          'cache'    => 'false'
  84  *                          ));
  85  *
  86  * // Here we go
  87  *
  88  * // Set the page title
  89  * $p->setTitle("My page");
  90  *
  91  * // Add optional meta data
  92  * $p->addMetaData("author", "My Name");
  93  *
  94  * // Put something into the body
  95  * $p->addBodyContent = "<p>some text</p>";
  96  *
  97  * // If at some point you want to clear the page content
  98  * // and output an error message, you can easily do that
  99  * // See the source for {@link toHtml} and {@link _getDoctype}
 100  * // for more details
 101  * if ($error) {
 102  *     $p->setTitle("Error!");
 103  *     $p->setBodyContent("<p>oops, we have an error: $error</p>");
 104  *     $p->display();
 105  *     die;
 106  * } // end error handling
 107  *
 108  * // print to browser
 109  * $p->display();
 110  * </code>
 111  *
 112  * Simple XHTML declaration example:
 113  * <code>
 114  * $p = new HTML_Page();
 115  * // An XHTML compliant page (with title) is automatically generated
 116  *
 117  * // This overrides the XHTML 1.0 Transitional default
 118  * $p->setDoctype('XHTML 1.0 Strict');
 119  *
 120  * // Put some content in here
 121  * $p->addBodyContent("<p>some text</p>");
 122  *
 123  * // print to browser
 124  * $p->display();
 125  * </code>
 126  *
 127  *
 128  * HTML examples:
 129  * --------------
 130  *
 131  * HTML 4.01 example:
 132  * ------------------
 133  * <code>
 134  * $p = new HTML_Page('doctype="HTML 4.01 Strict"');
 135  * $p->addBodyContent = "<p>some text</p>";
 136  * $p->display();
 137  * </code>
 138  *
 139  * nuke doctype declaration:
 140  * -------------------------
 141  * <code>
 142  * $p = new HTML_Page('doctype="none"');
 143  * $p->addBodyContent = "<p>some text</p>";
 144  * $p->display();
 145  * </code>
 146  *
 147  * @author       Adam Daniel <adaniel1@eesus.jnj.com>
 148  * @author       Klaus Guenther <klaus@capitalfocus.org>
 149  * @version      2.0
 150  * @since        PHP 4.0.3pl1
 151  */
 152 class HTML_Page extends HTML_Common {
 153
 154     /**
 155      * Contains the content of the &lt;body&gt; tag.
 156      *
 157      * @var     array
 158      * @access  private
 159      */
 160     var $_body = array();
 161
 162     /**
 163      * Controls caching of the page
 164      *
 165      * @var     bool
 166      * @access  private
 167      */
 168     var $_cache = false;
 169
 170     /**
 171      * Contains the character encoding string
 172      *
 173      * @var     string
 174      * @access  private
 175      */
 176     var $_charset = 'utf-8';
 177
 178     /**
 179      * Contains the !DOCTYPE definition
 180      *
 181      * @var array
 182      * @access private
 183      */
 184     var $_doctype = array('type'=>'xhtml','version'=>'1.0','variant'=>'transitional');
 185
 186     /**
 187      * Contains the page language setting
 188      *
 189      * @var     string
 190      * @access  private
 191      */
 192     var $_language = 'en';
 193
 194     /**
 195      * Array of meta tags
 196      *
 197      * @var     array
 198      * @access  private
 199      */
 200     var $_metaTags = array( 'standard' => array ( 'Generator' => 'PEAR HTML_Page' ) );
 201
 202     /**
 203      * Array of linked scripts
 204      *
 205      * @var  array
 206      * @access   private
 207      */
 208     var $_scripts = array();
 209
 210     /**
 211      * Array of linked scripts
 212      *
 213      * @var     array
 214      * @access  private
 215      */
 216     var $_simple = false;
 217
 218     /**
 219      * Array of included style declarations
 220      *
 221      * @var     array
 222      * @access  private
 223      */
 224     var $_style = array();
 225
 226     /**
 227      * Array of linked style sheets
 228      *
 229      * @var     array
 230      * @access  private
 231      */
 232     var $_styleSheets = array();
 233
 234     /**
 235      * HTML page title
 236      *
 237      * @var     string
 238      * @access  private
 239      */
 240     var $_title = '';
 241
 242     /**
 243      * Class constructor
 244      * Possible attributes are:
 245      * - general options:
 246      *     - "lineend" => "unix|win|mac" (Sets line ending style; defaults to unix.)
 247      *     - "tab" => string (Sets line ending style; defaults to \t.)
 248      *     - "cache"   => "false|true"
 249      *     - "charset" => charset string (Sets charset encoding; defaults to utf-8)
 250      * - XHTML specific:
 251      *     - "doctype"  => mixed (Sets XHTML doctype; defaults to XHTML 1.0 Transitional.)
 252      *     - "language" => two letter language designation. (Defines global document language; defaults to "en".)
 253      *
 254      * @param   mixed   $attributes     Associative array of table tag attributes
 255      *                                  or HTML attributes name="value" pairs
 256      * @access  public
 257      */
 258     function HTML_Page($attributes = "")
 259     {
 260         $commonVersion = 1.7;
 261         if (HTML_Common::apiVersion() < $commonVersion) {
 262             return PEAR::raiseError("HTML_Page version " . $this->apiVersion() . " requires " .
 263                 "HTML_Common version 1.2 or greater.", 0, PEAR_ERROR_TRIGGER);
 264         }
 265
 266         if ($attributes) {
 267             $attributes = $this->_parseAttributes($attributes);
 268         }
 269
 270         if (isset($attributes['lineend'])) {
 271             $this->setLineEnd($attributes['lineend']);
 272         }
 273
 274         if (isset($attributes['charset'])) {
 275             $this->setCharset($attributes['charset']);
 276         }
 277
 278         if (isset($attributes['doctype'])){
 279             if ($attributes['doctype'] == 'none') {
 280                 $this->_simple = true;
 281             } elseif ($attributes['doctype']) {
 282                 $this->setDoctype($attributes['doctype']);
 283             }
 284         }
 285
 286         if (isset($attributes['language'])) {
 287             $this->setLang($attributes['language']);
 288         }
 289
 290         if (isset($attributes['cache'])) {
 291             $this->setCache($attributes['cache']);
 292         }
 293
 294     }
 295
 296     /**
 297      * Generates the HTML string for the &lt;body&lt; tag
 298      *
 299      * @access  private
 300      * @return  string
 301      */
 302     function _generateBody()
 303     {
 304
 305         // get line endings
 306         $lnEnd = $this->_getLineEnd();
 307         $tab = $this->_getTab();
 308
 309         // If body attributes exist, add them to the body tag.
 310         // Depreciated because of CSS
 311         $strAttr = $this->_getAttrString($this->_attributes);
 312
 313         if ($strAttr) {
 314             $strHtml = "<body $strAttr>" . $lnEnd;
 315         } else {
 316             $strHtml = '<body>' . $lnEnd;
 317         }
 318
 319         // Allow for mixed content in the body array
 320         // Iterate through the array and process each element
 321         foreach ($this->_body as $element) {
 322             if (is_object($element)) {
 323                 if (is_subclass_of($element, "html_common")) {
 324                     $element->setTab($tab);
 325                     $element->setTabOffset(1);
 326                     $element->setLineEnd($lnEnd);
 327                 }
 328                 if (method_exists($element, "toHtml")) {
 329                     $strHtml .= $element->toHtml() . $lnEnd;
 330                 } elseif (method_exists($element, "toString")) {
 331                     $strHtml .= $element->toString() . $lnEnd;
 332                 }
 333             } elseif (is_array($element)) {
 334                 foreach ($element as $level2) {
 335                     if (is_subclass_of($level2, "html_common")) {
 336                         $level2->setTabOffset(1);
 337                         $level2->setTab($tab);
 338                         $level2->setLineEnd($lnEnd);
 339                     }
 340                     if (is_object($level2)) {
 341                         if (method_exists($level2, "toHtml")) {
 342                             $strHtml .= $level2->toHtml() . $lnEnd;
 343                         } elseif (method_exists($level2, "toString")) {
 344                             $strHtml .= $level2->toString() . $lnEnd;
 345                         }
 346                     } else {
 347                         $strHtml .= $tab . $level2 . $lnEnd;
 348                     }
 349                 }
 350             } else {
 351                 $strHtml .= $tab . $element . $lnEnd;
 352             }
 353         }
 354
 355         // Close tag
 356         $strHtml .= '</body>' . $lnEnd;
 357
 358         // Let's roll!
 359         return $strHtml;
 360     } // end func _generateHead
 361
 362     /**
 363      * Generates the HTML string for the &lt;head&lt; tag
 364      *
 365      * @return string
 366      * @access private
 367      */
 368     function _generateHead()
 369     {
 370
 371         // get line endings
 372         $lnEnd = $this->_getLineEnd();
 373         $tab = $this->_getTab();
 374
 375         $strHtml  = '<head>' . $lnEnd;
 376         $strHtml .= $tab . '<title>' . $this->getTitle() . '</title>' . $lnEnd;
 377
 378         // Generate META tags
 379         foreach ($this->_metaTags as $type => $tag) {
 380             foreach ($tag as $name => $content) {
 381                 if ($type == 'http-equiv') {
 382                     $strHtml .= $tab . "<meta http-equiv=\"$name\" content=\"$content\" />" . $lnEnd;
 383                 } elseif ($type == 'standard') {
 384                     $strHtml .= $tab . "<meta name=\"$name\" content=\"$content\" />" . $lnEnd;
 385                 }
 386             }
 387         }
 388
 389         // Generate stylesheet links
 390         $count = count($this->_styleSheets);
 391         for($intCounter=0; $intCounter < $count; $intCounter++) {
 392             $strStyleSheet = $this->_styleSheets[$intCounter];
 393             $strHtml .= $tab . "<link rel=\"stylesheet\" href=\"$strStyleSheet\" type=\"text/css\" />" . $lnEnd;
 394         }
 395
 396         // Generate stylesheet declarations
 397         foreach ($this->_style as $type => $content) {
 398             $strHtml .= $tab . '<style type="' . $type . '">' . $lnEnd;
 399             $strHtml .= $tab . $tab . '<!--' . $lnEnd;
 400             if (is_object($content)) {
 401
 402                 // first let's propagate line endings and tabs for other HTML_Common-based objects
 403                 if (is_subclass_of($content, "html_common")) {
 404                     $content->setTab($tab);
 405                     $content->setTabOffset(3);
 406                     $content->setLineEnd($lnEnd);
 407                 }
 408
 409                 // now let's get a string from the object
 410                 if (method_exists($content, "toString")) {
 411                     $strHtml .= $content->toString() . $lnEnd;
 412                 } else {
 413                     return PEAR::raiseError('Error: Body content object does not support  method toString().',
 414                     0,PEAR_ERROR_TRIGGER);
 415                 }
 416
 417             } else {
 418                 $strHtml .= $content . $lnEnd;
 419             }
 420             $strHtml .= $tab . $spacer . "-->" . $lnEnd;
 421             $strHtml .= $tab . "</style>" . $lnEnd;
 422         }
 423
 424         // Generate script file links
 425         $count = count($this->_scripts);
 426         for($intCounter=0; $intCounter < $count; $intCounter++) {
 427             $strType = $this->_scripts[$intCounter]["type"];
 428             $strSrc = $this->_scripts[$intCounter]["src"];
 429             $strHtml .= $tab . "<script type=\"$strType\" src=\"$strSrc\"></script>" . $lnEnd;
 430         }
 431
 432         // Close tag
 433         $strHtml .=  '</head>' . $lnEnd;
 434
 435         // Let's roll!
 436         return $strHtml;
 437     } // end func _generateHead
 438
 439     /**
 440      * Returns the doctype declaration
 441      *
 442      * @return string
 443      * @access private
 444      */
 445     function _getDoctype()
 446     {
 447         require('HTML/Page/Doctypes.php');
 448
 449         $type = $this->_doctype['type'];
 450         $version = $this->_doctype['version'];
 451         $variant = $this->_doctype['variant'];
 452
 453         $strDoctype = '';
 454
 455         if ($variant != '') {
 456             if (isset($doctype[$type][$version][$variant][0])) {
 457                 foreach ( $doctype[$type][$version][$variant] as $string) {
 458                     $strDoctype .= $string.$this->_getLineEnd();
 459                 }
 460             }
 461         } elseif ($version != '') {
 462             if (isset($doctype[$type][$version][0])) {
 463                 foreach ( $doctype[$type][$version] as $string) {
 464                     $strDoctype .= $string.$this->_getLineEnd();
 465                 }
 466             } else {
 467                 if (isset($default[$type][$version][0])) {
 468                     $this->_doctype = $this->_parseDoctypeString($default[$type][$version][0]);
 469                     $strDoctype = $this->_getDoctype();
 470                 }
 471             }
 472         } elseif ($type != '') {
 473             if (isset($default[$type][0])){
 474                 $this->_doctype = $this->_parseDoctypeString($default[$type][0]);
 475                 $strDoctype = $this->_getDoctype();
 476             }
 477         } else {
 478             $this->_doctype = $this->_parseDoctypeString($default['default'][0]);
 479             $strDoctype = $this->_getDoctype();
 480         }
 481
 482         if ($strDoctype) {
 483             return $strDoctype;
 484         } else {
 485             return PEAR::raiseError('Error: "'.$this->getDoctypeString().'" is an unsupported or illegal document type.',
 486                                     0,PEAR_ERROR_TRIGGER);
 487         }
 488
 489     } // end func _getDoctype
 490
 491     /**
 492      * Parses a doctype declaration like "XHTML 1.0 Strict" to an array
 493      *
 494      * @param   string  $string     The string to be parsed
 495      * @return string
 496      * @access private
 497      */
 498     function _parseDoctypeString($string)
 499     {
 500         $split = explode(' ',strtolower($string));
 501         $elements = count($split);
 502
 503         $array = array('type'=>$split[0],'version'=>$split[1],'variant'=>$split[2]);
 504
 505         return $array;
 506     } // end func _parseDoctypeString
 507
 508     /**
 509      * Sets the content of the &lt;body&gt; tag. If content already exists,
 510      * the new content is appended.
 511      * If you wish to overwrite whatever is in the body, use {@link setBody};
 512      * {@link unsetBody} completely empties the body without inserting new content.
 513      * It is possible to add objects, strings or an array of strings and/or objects
 514      * Objects must have a toString method.
 515      *
 516      * @param mixed $content  New &lt;body&gt; tag content (may be passed as a reference)
 517      * @access public
 518      */
 519     function addBodyContent($content)
 520     {
 521         $this->_body[] =& $content;
 522     } // end addBodyContent
 523
 524     /**
 525      * Adds a linked script to the page
 526      *
 527      * @param    string  $url        URL to the linked style sheet
 528      * @param    string  $type       Type of script. Defaults to 'text/javascript'
 529      * @access   public
 530      */
 531     function addScript($url, $type="text/javascript")
 532     {
 533         $this->_scripts["$type$url"] = array("type"=>$type, "src"=>$url);
 534     } // end func addScript
 535
 536     /**
 537      * Adds a linked stylesheet to the page
 538      *
 539      * @param    string  $url    URL to the linked style sheet
 540      * @access   public
 541      * @return   void
 542      */
 543     function addStyleSheet($url)
 544     {
 545         $this->_styleSheets[$url] = $url;
 546     } // end func addStyleSheet
 547
 548     /**
 549      * Adds a stylesheet declaration to the page.
 550      * Content can be a string or an object with a toString method.
 551      * Defaults to text/css.
 552      *
 553      * @access   public
 554      * @param    mixed   $content   Style declarations (may be passed as a reference)
 555      * @param    string  $type      Type of stylesheet (defaults to 'text/css')
 556      * @return   void
 557      */
 558     function addStyleDeclaration($content, $type = 'text/css')
 559     {
 560         $this->_style[$type] =& $content;
 561     } // end func addStyleDeclaration
 562
 563     /**
 564      * Returns the current API version
 565      *
 566      * @access   public
 567      * @returns  double
 568      */
 569     function apiVersion()
 570     {
 571         return 2.0;
 572     } // end func apiVersion
 573
 574     /**
 575      * Returns the document charset encoding.
 576      *
 577      * @access public
 578      * @returns string
 579      */
 580     function getCharset()
 581     {
 582         return $this->_charset;
 583     } // end setCache
 584
 585     /**
 586      * Returns the document type string
 587      *
 588      * @access private
 589      * @return string
 590      */
 591     function getDoctypeString()
 592     {
 593         $strDoctype = strtoupper($this->_doctype['type']);
 594         $strDoctype .= ' '.ucfirst(strtolower($this->_doctype['version']));
 595         if ($this->_doctype['variant']) {
 596             $strDoctype .= ' ' . ucfirst(strtolower($this->_doctype['variant']));
 597         }
 598         return trim($strDoctype);
 599     } // end func getDoctypeString
 600
 601     /**
 602      * Returns the document language.
 603      *
 604      * @return string
 605      * @access public
 606      */
 607     function getLang ()
 608     {
 609         return $this->_language;
 610     } // end func getLang
 611
 612     /**
 613      * Return the title of the page.
 614      *
 615      * @returns  string
 616      * @access   public
 617      */
 618     function getTitle()
 619     {
 620         if (!$this->_title){
 621             if ($this->_simple) {
 622                 return 'New Page';
 623             } else {
 624                 return 'New '. $this->getDoctypeString() . ' Compliant Page';
 625             }
 626         } else {
 627             return $this->_title;
 628         }
 629     } // end func getTitle
 630
 631     /**
 632      * Sets the content of the &lt;body&gt; tag. If content exists, it is overwritten.
 633      * If you wish to use a "safe" version, use {@link addBodyContent}
 634      * Objects must have a toString method.
 635      *
 636      * @param mixed $content New &lt;body&gt; tag content. May be an object. (may be passed as a reference)
 637      * @access public
 638      */
 639     function setBody($content)
 640     {
 641         $this->unsetBody();
 642         $this->_body[] =& $content;
 643     } // end setBody
 644
 645     /**
 646      * Unsets the content of the &lt;body&gt; tag.
 647      *
 648      * @access public
 649      */
 650     function unsetBody()
 651     {
 652         $this->_body = '';
 653     } // end unsetBody
 654
 655     /**
 656      * Defines if the document should be cached by the browser. Defaults to false.
 657      *
 658      * @param string $cache Options are currently 'true' or 'false'. Defaults to 'false'.
 659      * @access public
 660      */
 661     function setCache($cache = 'false')
 662     {
 663         if ($cache == 'true'){
 664             $this->_cache = true;
 665         } else {
 666             $this->_cache = false;
 667         }
 668     } // end setCache
 669
 670     /**
 671      * Defines if the document should be cached by the browser. Defaults to false.
 672      *
 673      * @param string $cache Options are currently 'true' or 'false'. Defaults to 'false'.
 674      * @access public
 675      * @returns void
 676      */
 677     function setCharset($type = 'utf-8')
 678     {
 679         $this->_charset = $type;
 680     } // end setCache
 681
 682     /**
 683      * Sets or alters the XHTML !DOCTYPE declaration. Can be set to "strict",
 684      * "transitional" or "frameset". Defaults to "transitional". This must come
 685      * _after_ declaring the character encoding with {@link setCharset} or directly
 686      * when the class is initiated {@link HTML_Page}.
 687      *
 688      * @param string $type   String containing a document type. Defaults to "XHTML 1.0 Transitional"
 689      * @access public
 690      * @returns void
 691      */
 692     function setDoctype($type = "XHTML 1.0 Transitional")
 693     {
 694         $this->_doctype = $this->_parseDoctypeString($type);
 695     } // end func setDoctype
 696
 697     /**
 698      * Sets the global document language declaration. Default is English.
 699      *
 700      * @access public
 701      * @param string $lang Two-letter language designation.
 702      */
 703     function setLang($lang = "en")
 704     {
 705         $this->_language = strtolower($lang);
 706     } // end setLang
 707
 708     /**
 709      * Sets or alters a meta tag.
 710      *
 711      * @param string  $name     Value of name or http-equiv tag
 712      * @param string  $content  Value of the content tag
 713      * @param bool    $http_equiv     META type "http-equiv" defaults to NULL
 714      * @return void
 715      * @access public
 716      */
 717     function setMetaData($name, $content, $http_equiv = false)
 718     {
 719         if ($http_equiv == true) {
 720             $this->_metaTags['http-equiv'][$name] = $content;
 721         } else {
 722             $this->_metaTags['standard'][$name] = $content;
 723         }
 724     } // end func setMetaData
 725
 726     /**
 727      * Easily sets or alters a refresh meta tag.
 728      * If no $url is passed, "self" is presupposed, and the appropriate URL
 729      * will be automatically generated.
 730      *
 731      * @param string  $time    Time till refresh (in seconds)
 732      * @param string  $url     Absolute URL or "self"
 733      * @param bool    $https   If $url = self, this allows for the https protocol defaults to NULL
 734      * @return void
 735      * @access public
 736      */
 737     function setMetaRefresh($time, $url = 'self', $https = false)
 738     {
 739         if ($url == 'self') {
 740             if ($https) {
 741                 $protocol = 'https://';
 742             } else {
 743                 $protocol = 'http://';
 744             }
 745             $url = $protocol . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
 746         }
 747         $this->setMetaData("Refresh", "$time; url=$url", true);
 748     } // end func setMetaRefresh
 749
 750     /**
 751      * Sets the title of the page
 752      *
 753      * @param    string    $title
 754      * @access   public
 755      * @returns  void
 756      */
 757     function setTitle($title)
 758     {
 759         $this->_title = $title;
 760     } // end func setTitle
 761
 762     /**
 763      * Generates and returns the complete page as a string.
 764      *
 765      * @return string
 766      * @access private
 767      */
 768     function toHTML()
 769     {
 770
 771         // get line endings
 772         $lnEnd = $this->_getLineEnd();
 773
 774         // get the doctype declaration
 775         $strDoctype = $this->_getDoctype();
 776
 777         //
 778         if ($this->_simple) {
 779             $strHtml = '<html>' . $lnEnd;
 780         } elseif ($this->_doctype['type'] == 'xhtml') {
 781             $strHtml  = '<?xml version="1.0" encoding="' . $this->_charset . '"?>' . $lnEnd;
 782             $strHtml .= $strDoctype . $lnEnd;
 783             $strHtml .= '<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="'.$this->_language.'">';
 784         } else {
 785             $strHtml  = $strDoctype . $lnEnd;
 786             $strHtml .= '<html>' . $lnEnd;
 787         }
 788         $strHtml .= $this->_generateHead();
 789         $strHtml .= $this->_generateBody();
 790         $strHtml .= '</html>';
 791         return $strHtml;
 792     } // end func toHtml
 793
 794     /**
 795      * Outputs the HTML content to the screen.
 796      *
 797      * @access    public
 798      */
 799     function display()
 800     {
 801         if(! $this->_cache) {
 802             header("Expires: Tue, 1 Jan 1980 12:00:00 GMT");
 803             header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
 804             header("Cache-Control: no-cache");
 805             header("Pragma: no-cache");
 806         }
 807
 808         // set character encoding
 809         header("Content-Type: text/html; charset=" . $this->_charset);
 810
 811         $strHtml = $this->toHTML();
 812         print $strHtml;
 813     } // end func display
 814
 815 }
 816 ?>