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