]> git.llucax.com Git - mecon/meconlib.git/blob - pear_lib_tmp/HTML/Page.php
BugFix. El metodo getAgentes() estaba usando ->_database para la base a consultar...
[mecon/meconlib.git] / 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 // HTML/Page/Namespaces.php is required in _getNamespace()
26
27 /**
28  * Base class for XHTML pages
29  *
30  * This class handles the details for creating a properly constructed XHTML page.
31  * Page caching, stylesheets, client side script, and Meta tags can be
32  * managed using this class.
33  * 
34  * The body may be a string, object, or array of objects or strings. Objects with
35  * toHtml() and toString() methods are supported.
36  * 
37  *
38  * XHTML Examples:
39  * ---------------
40  *
41  * Simplest example:
42  * -----------------
43  * <code>
44  * // the default doctype is XHTML 1.0 Transitional
45  * // All doctypes and defaults are set in HTML/Page/Doctypes.php
46  * $p = new HTML_Page();
47  *
48  * //add some content
49  * $p->addBodyContent("<p>some text</p>");
50  *
51  * // print to browser
52  * $p->display();
53  * </code>
54  * 
55  * Complex XHTML example:
56  * ----------------------
57  * <code>
58  * // The initializing code can also be in in the form of an HTML
59  * // attr="value" string.
60  * // Possible attributes are: charset, mime, lineend, tab, doctype, namespace, language and cache
61  * 
62  * $p = new HTML_Page(array (
63  *
64  *                          // Sets the charset encoding
65  *                          // utf-8 is default
66  *                          'charset'  => 'utf-8',
67  *
68  *                          // Sets the line end character
69  *                          // unix (\n) is default
70  *                          'lineend'  => 'unix',
71  *
72  *                          // Sets the tab string for autoindent
73  *                          // tab (\t) is default
74  *                          'tab'  => '  ',
75  *
76  *                          // This is where you define the doctype
77  *                          'doctype'  => "XHTML 1.0 Strict",
78  *
79  *                          // Global page language setting
80  *                          'language' => 'en',
81  *
82  *                          // If cache is set to true, the browser may
83  *                          // cache the output. Else 
84  *                          'cache'    => 'false'
85  *                          ));
86  *
87  * // Here we go
88  *
89  * // Set the page title
90  * $p->setTitle("My page");
91  * 
92  * // Add optional meta data
93  * $p->addMetaData("author", "My Name");
94  * 
95  * // Put something into the body
96  * $p->addBodyContent = "<p>some text</p>";
97  *
98  * // If at some point you want to clear the page content
99  * // and output an error message, you can easily do that
100  * // See the source for {@link toHtml} and {@link _getDoctype}
101  * // for more details
102  * if ($error) {
103  *     $p->setTitle("Error!");
104  *     $p->setBodyContent("<p>Houston, we have a problem: $error</p>");
105  *     $p->display();
106  *     die;
107  * } // end error handling
108  *
109  * // print to browser
110  * $p->display();
111  * </code>
112  * 
113  * Simple XHTML declaration example:
114  * <code>
115  * $p = new HTML_Page();
116  * // An XHTML compliant page (with title) is automatically generated
117  *
118  * // This overrides the XHTML 1.0 Transitional default
119  * $p->setDoctype('XHTML 1.0 Strict');
120  * 
121  * // Put some content in here
122  * $p->addBodyContent("<p>some text</p>");
123  *
124  * // print to browser
125  * $p->display();
126  * </code>
127  * 
128  *
129  * HTML examples:
130  * --------------
131  *
132  * HTML 4.01 example:
133  * ------------------
134  * <code>
135  * $p = new HTML_Page('doctype="HTML 4.01 Strict"');
136  * $p->addBodyContent = "<p>some text</p>";
137  * $p->display();
138  * </code>
139  * 
140  * nuke doctype declaration:
141  * -------------------------
142  * <code>
143  * $p = new HTML_Page('doctype="none"');
144  * $p->addBodyContent = "<p>some text</p>";
145  * $p->display();
146  * </code>
147  * 
148  * @author       Adam Daniel <adaniel1@eesus.jnj.com>
149  * @author       Klaus Guenther <klaus@capitalfocus.org>
150  * @version      2.0
151  * @since        PHP 4.0.3pl1
152  */
153 class HTML_Page extends HTML_Common {
154     
155     /**
156      * Contains the content of the &lt;body&gt; tag.
157      * 
158      * @var     array
159      * @access  private
160      */
161     var $_body = array();
162     
163     /**
164      * Controls caching of the page
165      * 
166      * @var     bool
167      * @access  private
168      */
169     var $_cache = false;
170     
171     /**
172      * Contains the character encoding string
173      * 
174      * @var     string
175      * @access  private
176      */
177     var $_charset = 'utf-8';
178     
179     /**
180      * Contains the !DOCTYPE definition
181      * 
182      * @var array
183      * @access private
184      */
185     var $_doctype = array('type'=>'xhtml','version'=>'1.0','variant'=>'transitional');
186     
187     /**
188      * Contains the page language setting
189      * 
190      * @var     string
191      * @access  private
192      */
193     var $_language = 'en';
194     
195     /**
196      * Array of meta tags
197      * 
198      * @var     array
199      * @access  private
200      */
201     var $_metaTags = array( 'standard' => array ( 'Generator' => 'PEAR HTML_Page' ) );
202     
203     /**
204      * Document mime type
205      * 
206      * @var  string
207      * @access   private
208      */
209     var $_mime = 'text/html';
210     
211     /**
212      * Document namespace
213      * 
214      * @var  string
215      * @access   private
216      */
217     var $_namespace = '';
218     
219     /**
220      * Array of linked scripts
221      * 
222      * @var  array
223      * @access   private
224      */
225     var $_scripts = array();
226     
227     /**
228      * Array of scripts placed in the header
229      * 
230      * @var  array
231      * @access   private
232      */
233     var $_script = array();
234     
235     /**
236      * Array of linked scripts
237      * 
238      * @var     array
239      * @access  private
240      */
241     var $_simple = false;
242     
243     /**
244      * Array of included style declarations
245      * 
246      * @var     array
247      * @access  private
248      */
249     var $_style = array();
250     
251     /**
252      * Array of linked style sheets
253      * 
254      * @var     array
255      * @access  private
256      */
257     var $_styleSheets = array();
258     
259     /**
260      * HTML page title
261      * 
262      * @var     string
263      * @access  private
264      */
265     var $_title = '';
266     
267     /**
268      * Class constructor
269      * Possible attributes are:
270      * - general options:
271      *     - "lineend" => "unix|win|mac" (Sets line ending style; defaults to unix.)
272      *     - "tab"     => string (Sets line ending style; defaults to \t.)
273      *     - "cache"   => "false|true"
274      *     - "charset" => charset string (Sets charset encoding; defaults to utf-8)
275      *     - "mime"    => mime encoding string (Sets document mime type; defaults to text/html)
276      * - XHTML specific:
277      *     - "doctype"  => string (Sets XHTML doctype; defaults to XHTML 1.0 Transitional.)
278      *     - "language" => two letter language designation. (Defines global document language; defaults to "en".)
279      *     - "namespace"  => string (Sets document namespace; defaults to the W3C defined namespace.)
280      * 
281      * @param   mixed   $attributes     Associative array of table tag attributes
282      *                                  or HTML attributes name="value" pairs
283      * @access  public
284      */
285     function HTML_Page($attributes = array())
286     {
287         $commonVersion = 1.7;
288         if (HTML_Common::apiVersion() < $commonVersion) {
289             return PEAR::raiseError("HTML_Page version " . $this->apiVersion() . " requires " .
290                 "HTML_Common version 1.2 or greater.", 0, PEAR_ERROR_TRIGGER);
291         }
292         
293         if ($attributes) {
294             $attributes = $this->_parseAttributes($attributes);
295         }
296         
297         if (isset($attributes['lineend'])) {
298             $this->setLineEnd($attributes['lineend']);
299         }
300         
301         if (isset($attributes['charset'])) {
302             $this->setCharset($attributes['charset']);
303         }
304         
305         if (isset($attributes['doctype'])){
306             if ($attributes['doctype'] == 'none') {
307                 $this->_simple = true;
308             } elseif ($attributes['doctype']) {
309                 $this->setDoctype($attributes['doctype']);
310             }
311         }
312         
313         if (isset($attributes['language'])) {
314             $this->setLang($attributes['language']);
315         }
316         
317         if (isset($attributes['mime'])) {
318             $this->setMimeEncoding($attributes['mime']);
319         }
320         
321         if (isset($attributes['namespace'])) {
322             $this->setNamespace($attributes['namespace']);
323         }
324         
325         if (isset($attributes['tab'])) {
326             $this->setTab($attributes['tab']);
327         }
328         
329         if (isset($attributes['cache'])) {
330             $this->setCache($attributes['cache']);
331         }
332         
333     }
334     
335     /**
336      * Generates the HTML string for the &lt;body&lt; tag
337      * 
338      * @access  private
339      * @return  string
340      */
341     function _generateBody()
342     {
343         
344         // get line endings
345         $lnEnd = $this->_getLineEnd();
346         $tab = $this->_getTab();
347         
348         // If body attributes exist, add them to the body tag.
349         // Depreciated because of CSS
350         $strAttr = $this->_getAttrString($this->_attributes);
351         
352         if ($strAttr) {
353             $strHtml = "<body $strAttr>" . $lnEnd;
354         } else {
355             $strHtml = '<body>' . $lnEnd;
356         }
357         
358         // Allow for mixed content in the body array
359         // Iterate through the array and process each element
360         foreach ($this->_body as $element) {
361             if (is_object($element)) {
362                 if (is_subclass_of($element, "html_common")) {
363                     $element->setTab($tab);
364                     $element->setTabOffset(1);
365                     $element->setLineEnd($lnEnd);
366                 }
367                 if (method_exists($element, "toHtml")) {
368                     $strHtml .= $element->toHtml() . $lnEnd;
369                 } elseif (method_exists($element, "toString")) {
370                     $strHtml .= $element->toString() . $lnEnd;
371                 }
372             } elseif (is_array($element)) {
373                 foreach ($element as $level2) {
374                     if (is_subclass_of($level2, "html_common")) {
375                         $level2->setTabOffset(1);
376                         $level2->setTab($tab);
377                         $level2->setLineEnd($lnEnd);
378                     }
379                     if (is_object($level2)) {
380                         if (method_exists($level2, "toHtml")) {
381                             $strHtml .= $level2->toHtml() . $lnEnd;
382                         } elseif (method_exists($level2, "toString")) {
383                             $strHtml .= $level2->toString() . $lnEnd;
384                         }
385                     } else {
386                         $strHtml .= $tab . $level2 . $lnEnd;
387                     }
388                 }
389             } else {
390                 $strHtml .= $tab . $element . $lnEnd;
391             }
392         }
393         
394         // Close tag
395         $strHtml .= '</body>' . $lnEnd;
396         
397         // Let's roll!
398         return $strHtml;
399     } // end func _generateHead
400     
401     /**
402      * Generates the HTML string for the &lt;head&lt; tag
403      * 
404      * @return string
405      * @access private
406      */
407     function _generateHead()
408     {
409         // close empty tags if XHTML
410         if ($this->_doctype['type'] == 'html'){
411             $tagEnd = '>';
412         } else {
413             $tagEnd = ' />';
414         }
415         
416         // get line endings
417         $lnEnd = $this->_getLineEnd();
418         $tab = $this->_getTab();
419         
420         $strHtml  = '<head>' . $lnEnd;
421         $strHtml .= $tab . '<title>' . $this->getTitle() . '</title>' . $lnEnd;
422         
423         // Generate META tags
424         foreach ($this->_metaTags as $type => $tag) {
425             foreach ($tag as $name => $content) {
426                 if ($type == 'http-equiv') {
427                     $strHtml .= $tab . "<meta http-equiv=\"$name\" content=\"$content\"" . $tagEnd . $lnEnd;
428                 } elseif ($type == 'standard') {
429                     $strHtml .= $tab . "<meta name=\"$name\" content=\"$content\"" . $tagEnd . $lnEnd;
430                 }
431             }
432         }
433         
434         // Generate stylesheet links
435         foreach ($this->_styleSheets as $strStyleSheet) {
436             $strHtml .= $tab . "<link rel=\"stylesheet\" href=\"$strStyleSheet\" type=\"text/css\"" . $tagEnd . $lnEnd;
437         }
438         
439         // Generate stylesheet declarations
440         foreach ($this->_style as $type => $content) {
441             $strHtml .= $tab . '<style type="' . $type . '">' . $lnEnd;
442             
443             // This is for full XHTML supporte.
444             if ($this->_mime == 'text/html' ) {
445                 $strHtml .= $tab . $tab . '<!--' . $lnEnd;
446             } else {
447                 $strHtml .= $tab . $tab . '<![CDATA[' . $lnEnd;
448             }
449             
450             if (is_object($content)) {
451                 
452                 // first let's propagate line endings and tabs for other HTML_Common-based objects
453                 if (is_subclass_of($content, "html_common")) {
454                     $content->setTab($tab);
455                     $content->setTabOffset(3);
456                     $content->setLineEnd($lnEnd);
457                 }
458                 
459                 // now let's get a string from the object
460                 if (method_exists($content, "toString")) {
461                     $strHtml .= $content->toString() . $lnEnd;
462                 } else {
463                     return PEAR::raiseError('Error: Style content object does not support  method toString().',
464                     0,PEAR_ERROR_TRIGGER);
465                 }
466                 
467             } else {
468                 $strHtml .= $content . $lnEnd;
469             }
470             
471             // See above note
472             
473             if ($this->_mime == 'text/html' ) {
474                 $strHtml .= $tab . $tab . '-->' . $lnEnd;
475             } else {
476                 $strHtml .= $tab . $tab . ']]>' . $lnEnd;
477             }
478             $strHtml .= $tab . '</style>' . $lnEnd;
479         }
480         
481         // Generate script file links
482         foreach ($this->_scripts as $strSrc => $strType) {
483             $strHtml .= $tab . "<script type=\"$strType\" src=\"$strSrc\"></script>" . $lnEnd;
484         }
485         
486         // Generate script declarations
487         foreach ($this->_script as $type => $content) {
488             $strHtml .= $tab . '<script type="' . $type . '">' . $lnEnd;
489             
490             // This is for full XHTML support.
491             if ($this->_mime == 'text/html' ) {
492                 $strHtml .= $tab . $tab . '<!--' . $lnEnd;
493             } else {
494                 $strHtml .= $tab . $tab . '<![CDATA[' . $lnEnd;
495             }
496             
497             if (is_object($content)) {
498                 
499                 // first let's propagate line endings and tabs for other HTML_Common-based objects
500                 if (is_subclass_of($content, "html_common")) {
501                     $content->setTab($tab);
502                     $content->setTabOffset(3);
503                     $content->setLineEnd($lnEnd);
504                 }
505                 
506                 // now let's get a string from the object
507                 if (method_exists($content, "toString")) {
508                     $strHtml .= $content->toString() . $lnEnd;
509                 } else {
510                     return PEAR::raiseError('Error: Script content object does not support  method toString().',
511                     0,PEAR_ERROR_TRIGGER);
512                 }
513                 
514             } else {
515                 $strHtml .= $content . $lnEnd;
516             }
517             
518             // See above note
519             if ($this->_mime == 'text/html' ) {
520                 $strHtml .= $tab . $tab . '-->' . $lnEnd;
521             } else {
522                 $strHtml .= $tab . $tab . ']]>' . $lnEnd;
523             }
524             $strHtml .= $tab . '</script>' . $lnEnd;
525         }
526         
527         // Close tag
528         $strHtml .=  '</head>' . $lnEnd;
529         
530         // Let's roll!
531         return $strHtml;
532     } // end func _generateHead
533     
534     /**
535      * Returns the doctype declaration
536      *
537      * @return mixed
538      * @access private
539      */
540     function _getDoctype()
541     {
542         require('HTML/Page/Doctypes.php');
543         
544         if (isset($this->_doctype['type'])) {
545             $type = $this->_doctype['type'];
546         }
547         
548         if (isset($this->_doctype['version'])) {
549             $version = $this->_doctype['version'];
550         }
551         
552         if (isset($this->_doctype['variant'])) {
553             $variant = $this->_doctype['variant'];
554         }
555         
556         $strDoctype = '';
557         
558         if (isset($variant)) {
559             if (isset($doctype[$type][$version][$variant][0])) {
560                 foreach ( $doctype[$type][$version][$variant] as $string) {
561                     $strDoctype .= $string.$this->_getLineEnd();
562                 }
563             }
564         } elseif (isset($version)) {
565             if (isset($doctype[$type][$version][0])) {
566                 foreach ( $doctype[$type][$version] as $string) {
567                     $strDoctype .= $string.$this->_getLineEnd();
568                 }
569             } else {
570                 if (isset($default[$type][$version][0])) {
571                     $this->_doctype = $this->_parseDoctypeString($default[$type][$version][0]);
572                     $strDoctype = $this->_getDoctype();
573                 }
574             }
575         } elseif (isset($type)) {
576             if (isset($default[$type][0])){
577                 $this->_doctype = $this->_parseDoctypeString($default[$type][0]);
578                 $strDoctype = $this->_getDoctype();
579             }
580         } else {
581             $this->_doctype = $this->_parseDoctypeString($default['default'][0]);
582             $strDoctype = $this->_getDoctype();
583         }
584         
585         if ($strDoctype) {
586             return $strDoctype;
587         } else {
588             return PEAR::raiseError('Error: "'.$this->getDoctypeString().'" is an unsupported or illegal document type.',
589                                     0,PEAR_ERROR_TRIGGER);
590         }
591         
592     } // end func _getDoctype
593     
594     /**
595      * Retrieves the document namespace
596      *
597      * @return mixed
598      * @access private
599      */
600     function _getNamespace()
601     {
602         require('HTML/Page/Namespaces.php');
603         
604         if (isset($this->_doctype['type'])) {
605             $type = $this->_doctype['type'];
606         }
607         
608         if (isset($this->_doctype['version'])) {
609             $version = $this->_doctype['version'];
610         }
611         
612         if (isset($this->_doctype['variant'])) {
613             $variant = $this->_doctype['variant'];
614         }
615         
616         $strNamespace = '';
617         
618         if (isset($variant)){
619             if (isset($namespace[$type][$version][$variant][0]) && is_string($namespace[$type][$version][$variant][0])) {
620                 $strNamespace = $namespace[$type][$version][$variant][0];
621             } elseif (isset($namespace[$type][$version][0]) && is_string($namespace[$type][$version][0]) ) {
622                 $strNamespace = $namespace[$type][$version][0];
623             } elseif (isset($namespace[$type][0]) && is_string($namespace[$type][0]) ) {
624                 $strNamespace = $namespace[$type][0];
625             }
626         } elseif (isset($version)) {
627             if (isset($namespace[$type][$version][0]) && is_string($namespace[$type][$version][0]) ) {
628                 $strNamespace = $namespace[$type][$version][0];
629             } elseif (isset($namespace[$type][0]) && is_string($namespace[$type][0]) ) {
630                 $strNamespace = $namespace[$type][0];
631             }
632         } else {
633             if (isset($namespace[$type][0]) && is_string($namespace[$type][0]) ) {
634                 $strNamespace = $namespace[$type][0];
635             }
636         }
637             
638         
639         if ($strNamespace) {
640             return $strNamespace;
641         } else {
642             return PEAR::raiseError('Error: "'.$this->getDoctypeString().'" does not have a default namespace. Use setNamespace() to define your namespace.',
643                                     0,PEAR_ERROR_TRIGGER);
644         }
645         
646     } // end func _getNamespace
647     
648     /**
649      * Parses a doctype declaration like "XHTML 1.0 Strict" to an array
650      *
651      * @param   string  $string     The string to be parsed
652      * @return string
653      * @access private
654      */
655     function _parseDoctypeString($string)
656     {
657         $split = explode(' ',strtolower($string));
658         $elements = count($split);
659         
660         if (isset($split[2])){
661             $array = array('type'=>$split[0],'version'=>$split[1],'variant'=>$split[2]);
662         } elseif (isset($split[1])){
663             $array = array('type'=>$split[0],'version'=>$split[1]);
664         } else {
665             $array = array('type'=>$split[0]);
666         }
667         
668         return $array;
669     } // end func _parseDoctypeString
670     
671     /**
672      * Sets the content of the &lt;body&gt; tag. If content already exists,
673      * the new content is appended.
674      * If you wish to overwrite whatever is in the body, use {@link setBody};
675      * {@link unsetBody} completely empties the body without inserting new content.
676      * It is possible to add objects, strings or an array of strings and/or objects
677      * Objects must have a toString method.
678      * 
679      * @param mixed $content  New &lt;body&gt; tag content (may be passed as a reference)
680      * @access public
681      */
682     function addBodyContent($content)
683     {
684         $this->_body[] =& $content;
685         if (is_object($content)) {
686             if (method_exists($content, "toStyleSheet")) {
687                 $this->addStyleSheet($content->toStyleSheet());
688             }
689             if (method_exists($content, "toScript")) {
690                                 $script = $content->toScript();
691                                 if (is_array($script)) {
692                                         $this->addScript($script[0], $script[1]);
693                                 } else {
694                                         $this->addScript($script);
695                                 }
696             }
697         } elseif (is_array($content)) {
698                         foreach ($content as $element) {
699                         if (is_object($content)) {
700                                         if (method_exists($element, "toStyleSheet")) {
701                                                 $this->addStyleSheet($element->toStyleSheet());
702                                         }
703                                         if (method_exists($element, "toScript")) {
704                                                 $script = $element->toScript();
705                                                 if (is_array($script)) {
706                                                         $this->addScript($script[0], $script[1]);
707                                                 } else {
708                                                         $this->addScript($script);
709                                                 }
710                                         }
711                                 }
712                         }
713                 }
714     } // end addBodyContent    
715     
716     /**
717      * Adds a linked script to the page
718      * 
719      * @param    string  $url        URL to the linked script
720      * @param    string  $type       Type of script. Defaults to 'text/javascript'
721      * @access   public
722      */
723     function addScript($url, $type="text/javascript")
724     {
725         $this->_scripts[$url] = $type;
726     } // end func addScript
727     
728     /**
729      * Adds a script to the page.
730      * Content can be a string or an object with a toString method.
731      * Defaults to text/javascript.
732      * 
733      * @access   public
734      * @param    mixed   $content   Script (may be passed as a reference)
735      * @param    string  $type      Scripting mime (defaults to 'text/javascript')
736      * @return   void
737      */
738     function addScriptDeclaration($content, $type = 'text/javascript')
739     {
740         $this->_script[strtolower($type)] =& $content;
741     } // end func addScriptDeclaration
742     
743     /**
744      * Adds a linked stylesheet to the page
745      * 
746      * @param    string  $url    URL to the linked style sheet
747      * @access   public
748      * @return   void
749      */
750     function addStyleSheet($url)
751     {
752         $this->_styleSheets[$url] = $url;
753     } // end func addStyleSheet
754     
755     /**
756      * Adds a stylesheet declaration to the page.
757      * Content can be a string or an object with a toString method.
758      * Defaults to text/css.
759      * 
760      * @access   public
761      * @param    mixed   $content   Style declarations (may be passed as a reference)
762      * @param    string  $type      Type of stylesheet (defaults to 'text/css')
763      * @return   void
764      */
765     function addStyleDeclaration($content, $type = 'text/css')
766     {
767         $this->_style[strtolower($type)] =& $content;
768     } // end func addStyleDeclaration
769     
770     /**
771      * Returns the current API version
772      * 
773      * @access   public
774      * @returns  double
775      */
776     function apiVersion()
777     {
778         return 2.0;
779     } // end func apiVersion
780     
781     /**
782      * Returns the document charset encoding.
783      * 
784      * @access public
785      * @returns string
786      */
787     function getCharset()
788     {
789         return $this->_charset;
790     } // end setCache
791     
792     /**
793      * Returns the document type string
794      *
795      * @access private
796      * @return string
797      */
798     function getDoctypeString()
799     {
800         $strDoctype = strtoupper($this->_doctype['type']);
801         $strDoctype .= ' '.ucfirst(strtolower($this->_doctype['version']));
802         if ($this->_doctype['variant']) {
803             $strDoctype .= ' ' . ucfirst(strtolower($this->_doctype['variant']));
804         }
805         return trim($strDoctype);
806     } // end func getDoctypeString
807     
808     /**
809      * Returns the document language.
810      * 
811      * @return string
812      * @access public
813      */
814     function getLang ()
815     {
816         return $this->_language;
817     } // end func getLang
818     
819     /**
820      * Return the title of the page.
821      * 
822      * @returns  string
823      * @access   public
824      */
825     function getTitle()
826     {
827         if (!$this->_title){
828             if ($this->_simple) {
829                 return 'New Page';
830             } else {
831                 return 'New '. $this->getDoctypeString() . ' Compliant Page';
832             }
833         } else {
834             return $this->_title;
835         }
836     } // end func getTitle
837     
838     /**
839      * Sets the content of the &lt;body&gt; tag. If content exists, it is overwritten.
840      * If you wish to use a "safe" version, use {@link addBodyContent}
841      * Objects must have a toString method.
842      * 
843      * @param mixed $content New &lt;body&gt; tag content. May be an object. (may be passed as a reference)
844      * @access public
845      */
846     function setBody($content)
847     {
848         $this->unsetBody();
849         $this->addBodyContent($content);
850     } // end setBody
851     
852     /**
853      * Unsets the content of the &lt;body&gt; tag.
854      * 
855      * @access public
856      */
857     function unsetBody()
858     {
859         $this->_body = '';
860     } // end unsetBody
861         
862     /**
863      * Defines if the document should be cached by the browser. Defaults to false.
864      * 
865      * @param string $cache Options are currently 'true' or 'false'. Defaults to 'false'.
866      * @access public
867      */
868     function setCache($cache = 'false')
869     {
870         if ($cache == 'true'){
871             $this->_cache = true;
872         } else {
873             $this->_cache = false;
874         }
875     } // end setCache
876     
877     /**
878      * Defines if the document should be cached by the browser. Defaults to false.
879      * 
880      * @param string $cache Options are currently 'true' or 'false'. Defaults to 'false'.
881      * @access public
882      * @returns void
883      */
884     function setCharset($type = 'utf-8')
885     {
886         $this->_charset = $type;
887     } // end setCache
888     
889     /**
890      * Sets or alters the XHTML !DOCTYPE declaration. Can be set to "strict",
891      * "transitional" or "frameset". Defaults to "transitional". This must come
892      * _after_ declaring the character encoding with {@link setCharset} or directly
893      * when the class is initiated {@link HTML_Page}.
894      * 
895      * @param string $type   String containing a document type. Defaults to "XHTML 1.0 Transitional"
896      * @access public
897      * @returns void
898      */
899     function setDoctype($type = "XHTML 1.0 Transitional")
900     {
901         $this->_doctype = $this->_parseDoctypeString($type);
902     } // end func setDoctype
903     
904     /**
905      * Sets the global document language declaration. Default is English.
906      * 
907      * @access public
908      * @param string $lang Two-letter language designation.
909      */
910     function setLang($lang = "en")
911     {
912         $this->_language = strtolower($lang);
913     } // end setLang
914     
915     /**
916      * Sets or alters a meta tag.
917      * 
918      * @param string  $name     Value of name or http-equiv tag
919      * @param string  $content  Value of the content tag
920      * @param bool    $http_equiv     META type "http-equiv" defaults to NULL
921      * @return void
922      * @access public
923      */
924     function setMetaData($name, $content, $http_equiv = false)
925     {
926         if ($http_equiv == true) {
927             $this->_metaTags['http-equiv'][$name] = $content;
928         } else {
929             $this->_metaTags['standard'][$name] = $content;
930         }
931     } // end func setMetaData
932     
933     /**
934      * Sets an http-equiv Content-Type meta tag
935      * 
936      * @access   public
937      * @returns  void
938      */
939     function setMetaContentType()
940     {
941         $this->setMetaData('Content-Type', $this->_mime . '; charset=' . $this->_charset , true );
942     } // end func setMetaContentType
943     
944     /**
945      * Easily sets or alters a refresh meta tag. 
946      * If no $url is passed, "self" is presupposed, and the appropriate URL
947      * will be automatically generated.
948      * 
949      * @param string  $time    Time till refresh (in seconds)
950      * @param string  $url     Absolute URL or "self"
951      * @param bool    $https   If $url = self, this allows for the https protocol defaults to NULL
952      * @return void
953      * @access public
954      */
955     function setMetaRefresh($time, $url = 'self', $https = false)
956     {
957         if ($url == 'self') {
958             if ($https) { 
959                 $protocol = 'https://';
960             } else {
961                 $protocol = 'http://';
962             }
963             $url = $protocol . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
964         }
965         $this->setMetaData("Refresh", "$time; url=$url", true);
966     } // end func setMetaRefresh
967     
968     /**
969      * Sets the document MIME encoding that is sent to the browser.
970      * 
971      * @param    string    $type
972      * @access   public
973      * @returns  void
974      */
975     function setMimeEncoding($type = 'text/html')
976     {
977         $this->_mime = strtolower($type);
978     } // end func setMimeEncoding
979     
980     /**
981      * Sets the document namespace
982      * 
983      * @param    string    $namespace  Optional. W3C namespaces are used by default.
984      * @access   public
985      * @returns  void
986      */
987     function setNamespace($namespace = '')
988     {
989         if (isset($namespace)){
990             $this->_namespace = $namespace;
991         } else {
992             $this->_namespace = $this->_getNamespace();
993         }
994     } // end func setTitle
995     
996     /**
997      * Sets the title of the page
998      * 
999      * @param    string    $title
1000      * @access   public
1001      * @returns  void
1002      */
1003     function setTitle($title)
1004     {
1005         $this->_title = $title;
1006     } // end func setTitle
1007     
1008     /**
1009      * Generates and returns the complete page as a string.
1010      * 
1011      * @return string
1012      * @access private
1013      */
1014     function toHTML()
1015     {
1016         
1017         // get line endings
1018         $lnEnd = $this->_getLineEnd();
1019         
1020         // get the doctype declaration
1021         $strDoctype = $this->_getDoctype();
1022         
1023         // This determines how the doctype is declared
1024         if ($this->_simple) {
1025             
1026             $strHtml = '<html>' . $lnEnd;
1027             
1028         } elseif ($this->_doctype['type'] == 'xhtml') {
1029             
1030             // get the namespace if not already set
1031             if (!$this->_namespace){
1032                 $this->_namespace = $this->_getNamespace();
1033             }
1034             
1035             $strHtml  = '<?xml version="1.0" encoding="' . $this->_charset . '"?>' . $lnEnd;
1036             $strHtml .= $strDoctype . $lnEnd;
1037             $strHtml .= '<html xmlns="' . $this->_namespace . '" xml:lang="' . $this->_language . '">' . $lnEnd;
1038             
1039         } else {
1040             
1041             $strHtml  = $strDoctype . $lnEnd;
1042             $strHtml .= '<html>' . $lnEnd;
1043             
1044         }
1045
1046         $strHtml .= $this->_generateHead();
1047         $strHtml .= $this->_generateBody();
1048         $strHtml .= '</html>';
1049         return $strHtml;
1050     } // end func toHtml
1051
1052     /**
1053      * Outputs the HTML content to the screen.
1054      * 
1055      * @access    public
1056      */
1057     function display()
1058     {
1059         if(! $this->_cache) {
1060             header("Expires: Tue, 1 Jan 1980 12:00:00 GMT");
1061             header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
1062             header("Cache-Control: no-cache");
1063             header("Pragma: no-cache");
1064         }
1065         
1066         // set character encoding
1067         header('Content-Type: ' . $this->_mime .  '; charset=' . $this->_charset);
1068         
1069         $strHtml = $this->toHTML();
1070         print $strHtml;
1071     } // end func display
1072     
1073 }
1074 ?>