com.newsblob.phphtmllib/widgets/HTMLPageClass.inc

<?php

/**
 * This contains the HTMLPageClass widget
 *
 * $Id: HTMLPageClass.inc,v 1.25 2003/07/23 21:05:38 hemna Exp $
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @package phpHtmlLib
 * 
 */

/**
 * Get all the required files for this class
 */
require_once($phphtmllib."/HTMLTagClass.inc");


/**
 * class the constructs and renders an entire
 * HTML/XHTML document. 
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @package phpHtmlLib
 */
class HTMLPageClass {

    /**
     * HEADtag object that holds all content
     * for the head.
     * @var  object
     * @access   private
     */
    var $_head = NULL;

    /**
     * TITLEtag object that holds the title
     * of the page.
     * @var  object
     * @access   private
     */
    var $_title = NULL;

    /**
     * SCRIPTtag object that holds javascript
     * code for the head tag.
     * @var  object
     * @access   private
     */
    var $_head_js = NULL;

    /**
     * STYLEtag object that holds css code
     * for the head.
     * @var  object
     * @access   private
     */
    var $_head_style = NULL;

    /**
     * holds an array of LINKtag objects
     * in the head tag that reference an
     * external stylesheet file.
     * @var  array.
     * @access   private
     */
    var $_head_css_link_arr = array();

    /**
     * holds an array of SCRIPTtag objects
     * in the head tag that reference an
     * an extern javascript file.
     * @var  array
     * @access   private
     */
    var $_head_js_link_arr = array();

    /**
     * character set to be used in this
     * page.  This gets automatically
     * placed in the Content-Type
     * META tag.
     * @var  string
     * @access   private
     */
    var $_charset = "iso-8859-1";


    /**
     * The encoding of the XHTML
     * XML tag
     */
    var $_xml_encoding = "UTF-8";

    /**
     * BODYtag object that holds all content
     * for the body tag.
     * @var  object
     * @access   private
     */
    var $_body = NULL;

    /**
     * DOCTYPEag object that sets the document
     * type.  This gets rendered prior to <html>
     * @var  object
     * @access   private
     */
    var $_doctype = NULL;

    /**
     * flag to tell the class to try and
     * change the http headers to output
     * document of type text, instead of
     * html.  This is helpfull for debugging.
     * @var boolean
     * @access private
     */
    var $_text_debug = FALSE;

    /**
     * This holds a FRAMESETtag object.
     * This is used if the person is trying
     * to render a frameset page.
     *
     * @var FRAMESETtag object.
     * @access private
     */
    var $_frameset = NULL;


    /**
     * This holds the text used to display
     * a body content when a browser doesn't
     * support framesets
     *
     * @var string
     * @access private
     */
    var $_noframes_text = "Sorry, your browser does not support frames";


    /**
     * This holds the attributes for the
     * <html> tag.
     *
     * @var array
     */
    var $_html_attributes = array();

        /**
         * keeps track of which widgets we have
         * automatically pulled in css for
         *
         * @var array
         */
        var $_widget_css_auto = array();

        /**
         * keeps track of which widgets we have
         * automatically pulled in js for
         *
         * @var array
         */
        var $_widget_js_auto = array();


        /**
         * Holds the value of the indent 
         * style the user wants to render 
         * the page w/
         *
         * @var int
         */
        var $_indent_style = 0;


    /**
     * Class Constructor
     * @param   mixed  - $title Title string or TITLEtag object for the page.
     * @param   string - one of 3 types of html to render.  Setting this will
     *                   make the object declare the gobal define which tells
     *                   all of the tag objects what type of html tags to render.
     *                   some tags support special features.  such as the <IMG>
     *                   tag.  If xhtml is selected, the the IMGtag object and all
     *                   utility functions will not render "border=0" as a default
     *                   attribute, since this is not proper xhtml.
     *                   "html" - HTML 4.0 (default)
     *                   "xhtml_transitional" - render xhtml instead of html
     *                                        - doctype is XHTML transitional.
     *                   "xhtml_strict" - render xhtml instead of html 4.0.
     *                                  - doctype is XHTML strict.
         * @param   int   - one of 2 types.  INDENT_NICE or INDENT_LEFT_JUSTIFY
         *                  This tells the page how to render the indenting of the
         *                  output.  By default it is set to INDENT_NICE, which nicely
         *                  indents each nested tag.  You can have all tags rendered
         *                  left justified (smaller size in output) by using 
         *                  INDENT_LEFT_JUSTIFY
     *                   
     * @access   public
     */
    function HTMLPageClass($title=NULL, $html_type=HTML, $indent_style=INDENT_NICE) {

        switch ($html_type) {
                case HTML:
                default:
            $this->build_doctype("-//W3C//DTD HTML 4.01 Transitional//EN"); 
            $GLOBALS["HTML_RENDER_TYPE"] = HTML;
            break;

        case XHTML_STRICT:
            $this->build_doctype("-//W3C//DTD XHTML 1.0 Strict//EN", 
                                                                 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd");
            $GLOBALS["HTML_RENDER_TYPE"] = XHTML_STRICT;
            $this->set_html_attributes( array( "xmlns" => "http://www.w3.org/1999/xhtml",
                                               "xml:lang" => "en",
                                               "lang" => "en") );
            break;

        case XHTML:
        case XHTML_TRANSITIONAL:
            $this->build_doctype("-//W3C//DTD XHTML 1.0 Transitional//EN",
                                                                 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd");
            $GLOBALS["HTML_RENDER_TYPE"] = XHTML;
            $this->set_html_attributes( array( "xmlns" => "http://www.w3.org/1999/xhtml",
                                               "xml:lang" => "en",
                                               "lang" => "en") );
            break;

            //What else needs to be done to properly support
            //XHTML frameset?  TODO LIST for 1.1
        case XHTML_FRAMESET:
                        $this->build_doctype("-//W3C//DTD XHTML 1.0 Frameset//EN",
                                                                 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd");
            $GLOBALS["HTML_RENDER_TYPE"] = XHTML_FRAMESET;
            break;
        }

        $this->_head = new HEADtag;
        $this->_head_js = html_script();
        $this->_head_style = html_style();
        $this->_create_body();
        if ($title != NULL) {
            $this->set_title( $title );
        }

                $this->_indent_style = $indent_style;
    }

    //**************************************************
    //* HEAD tag related functions
    //**************************************************


    /**
     * this adds content to the head tag
     * of the page
     *
     * @param mixed - any content to add
     */
    function add_head_content( ) {
                $num_args = func_num_args();
                for ($i=0;$i<$num_args;$i++) {
                        $this->_head->add(func_get_arg($i));
                }
    }

    /**
     * Same ass add_head_content()
     *
     * @deprecated - use add_head_content();
     */
    function push_head_content( ) {
                $args = func_get_args();
        call_user_func_array( array(&$this, "add_head_content"), $args);
    }


    /**
     * adds raw javascript to the head which
     * will automatically get wrapped in a
     * <script language="JavaScript"> tag.
     * @param mixed $content - raw javascript code to add to the head
     */
    function add_head_js( $content ) {
        $this->_head_js->push( $content );
    }

    /**
     * Same ass add_head_js()
     *
     * @deprecated - use add_head_js();
     */
    function push_head_js( $content ) {
        $this->add_head_js( $content );        
    }

        /**
         * this function adds raw css to the
         * <head> tag.  It will automatically
         * be wrapped in a <style type="text/css">
         *
         * @param string - the raw css
         */
        function add_head_css( $css ) {
                $this->_head_style->push( $css );
        }

    /**
     *  set the title of the page output.
     *  @param  mixed  $title - the title of the html page
     *                          can be TITLEtag object.
     *
     */
    function set_title( $title ) {
        if (is_object($title)) {
            if ($title->_tag == "title") {
                $this->_title = $title;
            } else {
                //they did something funky here.
                return -1;
            }
        } else {
            $this->_title = html_title( $title );
        }
    }

    /**
     * pushes a css external reference to the head area
     * @param mixed   $link - link tag object or $url for a css.
     */
    function add_css_link( $link ) {
        if (is_object($link)) {
            $css = $link;
        } else {
            $css = html_link($link, "stylesheet", "text/css");
        }
        $this->_head_css_link_arr[] = $css;
    }

    /**
     * Same ass add_css_link()
     *
     * @deprecated - use add_css_link();
     */
    function push_css_link( $link ) {
        $this->add_css_link( $link );

    }

    /**
     * This adds a link to an external Javascript
     * file, which will get rendered in the head.
     *
     * @param  mixed $link - script tag object or $url of .js file.
     */
    function add_js_link( $link ) {
        if (is_object($link)) {
            $js = $link;
        } else {
            $js = html_script($link);
        }
        $this->_head_js_link_arr[] = $js;
    }

    /**
     * same as add_js_link()
     * 
     * @deprecated
     */
    function push_js_link( $link ) {
        $this->add_js_link( $link );
    }

    /**
     * Automatically set a page meta tag refresh
     * @param int     $time - time in seconds to refresh
     * @param string  $url - the url to go to.
     */
    function set_refresh( $time, $url=NULL ) {
        if ($url) {
            $time .= ";url=$url";
        }
        $this->push_head_content( html_meta($time, "refresh") );
    }

    /**
     * set the character set
     * @param string  $charset - the charset for the meta tag
     *
     */
    function set_charset( $charset ) {
        $this->_charset = $charset;
    }

    /**
     * This sets the encoding type for 
     * XHTML documents
     *
     * @param string - the encoding parameter
     */
    function set_encoding( $encoding ) {
        $this->_xml_encoding = $encoding;
    }

    /**
     * This method sets the lang, and xml:lang
     * setting in the HTML tag.
     *
     * @param string - the language
     */
    function set_language( $language ) {
        $this->_html_attributes["xml:lang"] = $language;
        $this->_html_attributes["lang"] = $language;
    }

    /**
     * This function is used to set the FRAMSETtag
     * object for this page.  This automatically
     * sets the output for this page object to 
     * be a frameset.
     *
     * @param FRAMESETtag object - $frameset
     */
    function set_frameset( $frameset ) {
        if (is_object($frameset)) {
            if ($frameset->get_tag() == "frameset") {
                $this->_frameset = $frameset;
            }
        }
    }


    /**
     * This function returns the
     * attributes to be used for the
     * <html> tag.
     *
     * @return array();
     */
    function get_html_attributes() {
        return $this->_html_attributes;        
    }

    /**
     * This function sets the attributes
     * for the <html> tag
     *
     * @param array - the name=>value 
     *                pair for the
     *               attributes
     */
    function set_html_attributes( $attributes ) {
        $this->_html_attributes = $attributes;
    }   


    /**
     * this builds the content type meta tag.
     *
     */
    function _build_content_type_tag() {
        $content_type = "text/html; charset=" . $this->_charset;
        return html_meta($content_type, "Content-Type");
    }

    //**************************************************
    //* BODY tag related functions
    //**************************************************


    /**
     * This function adds content to the <body>
     * area of the page.
     *
     * @param mixed - any # of parameters
     */
    function add() {
        $num_args = func_num_args();
        for ($i=0;$i<$num_args;$i++) {
                        $arg = func_get_arg($i);
                        //see if the arg is an object
                        //and a child of BaseWidget.
                        if (is_object($arg) && is_subclass_of( $arg, "basewidget")) {
                                //see if they have an js they need to include
                                $js = "";
                                $js = $arg->get_javascript();
                                $class_name = get_class($arg);
                                if ($js != "" && !$this->_widget_js_auto[$class_name]) {
                                        $this->add_head_js( str_replace(chr(9),'', $js) );
                                        $this->_widget_js_auto[$class_name] = TRUE;
                                }
                        }
            $this->_body->add(func_get_arg($i));
        }        
    }

    /**
     * Same as add()
     *
     * @deprecated - use add()
     *
     */
    function push( ) {        
        $args = func_get_args();
        call_user_func_array( array(&$this, "add"), $args);
    }

    /**
     * Adds the content reference to the <body>
     * tag for later use.
     *
     * @param   mixed   $content - content to add
     */
    function add_reference( &$content ) {
        $this->_body->push_reference( $content );
    }

    /**
     * Same as add()
     *
     * @deprecated - use add()
     *
     */
    function push_reference( &$content ) {
        $this->add_reference( $content );        
    }

    /**
     * This is responsible for creating the 
     * BODYtag object.  We only will 
     * create a new $this->_body if it doesn't
     * already exist.  
     *
     */
    function _create_body() {
        if ($this->_body == NULL) {
            $this->_body = new BODYtag;
            //$this->_body->add( " " );
        }
    }

    /**
     * set attributes of body tag
     * @param array $attributes the name=>value pairs
     *
     */
    function set_body_attributes( $attributes ) {
        if (!is_object( $this->_body )) {
            $this->_create_body();
        }
        $this->_body->set_tag_attributes( $attributes );
    }

        /**
         * This function is used to build the DOCTYPE 
         * tag for the page.  It will automatically
         * create a DOCTYPE with a document_element of "html"
         * and a source of "PUBLIC"
         *
         * @param string - link1
         * @param string - link2
         */
        function build_doctype($link1, $link2=NULL) {
                $this->_doctype = xml_doctype("html", "PUBLIC", $link1, $link2);
        }

    //**************************************************
    //* General functions
    //**************************************************

    /**
     * set the $_text_debug flag
     * @param   $flag - boolean.
     */
    function set_text_debug( $flag ) {
        $this->_text_debug = $flag;
    }


    //**************************************************
    //* RENDERING of content related functions
    //**************************************************

    /**
     *  builds the head object and its content.
     *
     */
    function _build_head() {

        $this->_head->add( $this->_build_content_type_tag() );

        if ($this->_title) {
            $this->_head->add( $this->_title );
        }
        
        if ( $this->_head_style->count_content() ) {
            $this->_head->add( $this->_head_style );
        }
        if ( $this->_head_js->count_content() ) {
            $this->_head->add( $this->_head_js );
        }

        if (count($this->_head_css_link_arr)) {
            foreach( $this->_head_css_link_arr as $css) {
                $this->_head->add( $css );
            }
        }

        if (count($this->_head_js_link_arr)) {
            foreach( $this->_head_js_link_arr as $js) {
                $this->_head->add( $js );
            }
        }
    }

    /**
     * This builds a frameset body tag
     * wrapped in a <noframes> tag.
     *
     * @return NOFRAMEStag object.
     */
    function _frameset_wrap_body() {
        $noframes = new NOFRAMEStag;
        $body = new BODYtag;
        $body->add( $this->_noframes_text );
        $noframes->add( $body );
        return $noframes;
    }

    /**
     * render the page.
         *
         *
         * @return string the raw html output.
     */
    function render() {

        //lets use ourself to render the debug page!
        if ($this->_text_debug) {
            $page = new HTMLPageClass;
            $page->add_css_link("/phphtmllib/css/HTMLPageClass.css");            
        }

        $newline = " ";
        $attributes = $this->get_html_attributes();
        $html = new HTMLtag( $attributes );
        $html->add( $newline );
        $this->_build_head();
        $html->add( $this->_head );

        //Check to see if we are rendering
        //a frameset page.
        if ($this->_frameset != NULL) {
            //Looks like they have set the frameset
            //member, so we are rendering a frameset
            //we will automatically wrap the <body>
            $html->add( $newline );
            $html->add( $this->_frameset );
            $html->add( $newline );
            $html->add( $this->_frameset_wrap_body() );
        } else {
            $html->add( $newline );
            //$this->_body->add( $newline );
            $html->add( $this->_body );
        }        

        $html-> add( $newline );

        if ($this->_text_debug) {
            if ($GLOBALS["HTML_RENDER_TYPE"] == XHTML_STRICT) {
                $xml = new XMLtag(array("version" => "1.0",
                                        "encoding"=>$this->_xml_encoding));
                $page->add( $xml->render(0,1) );
            }
            $page->add( $this->_doctype->render(0,1) );
            $page->add( $html->render($this->_indent_style,1) );
            return $page->render();
        } else {
            $output = '';
            if ($GLOBALS["HTML_RENDER_TYPE"] == XHTML_STRICT) {
                $xml = new XMLtag(array("version" => "1.0",
                                        "encoding"=>$this->_xml_encoding));
                $output = $xml->render(0);
            }
            $output .= $this->_doctype->render();                       
            $output .= $html->render($this->_indent_style);
            return $output;
        }
    }
}


?>
1	<?php
2
3	/**
4	* This contains the HTMLPageClass widget
5	*
6	* $Id: HTMLPageClass.inc,v 1.25 2003/07/23 21:05:38 hemna Exp $
7	*
8	* @author Walter A. Boring IV <waboring@buildabetterweb.com>
9	* @package phpHtmlLib
10	*
11	*/
12
13	/**
14	* Get all the required files for this class
15	*/
16	require_once($phphtmllib."/HTMLTagClass.inc");
17
18
19	/**
20	* class the constructs and renders an entire
21	* HTML/XHTML document.
22	*
23	* @author Walter A. Boring IV <waboring@buildabetterweb.com>
24	* @package phpHtmlLib
25	*/
26	class HTMLPageClass {
27
28	/**
29	* HEADtag object that holds all content
30	* for the head.
31	* @var object
32	* @access private
33	*/
34	var $_head = NULL;
35
36	/**
37	* TITLEtag object that holds the title
38	* of the page.
39	* @var object
40	* @access private
41	*/
42	var $_title = NULL;
43
44	/**
45	* SCRIPTtag object that holds javascript
46	* code for the head tag.
47	* @var object
48	* @access private
49	*/
50	var $_head_js = NULL;
51
52	/**
53	* STYLEtag object that holds css code
54	* for the head.
55	* @var object
56	* @access private
57	*/
58	var $_head_style = NULL;
59
60	/**
61	* holds an array of LINKtag objects
62	* in the head tag that reference an
63	* external stylesheet file.
64	* @var array.
65	* @access private
66	*/
67	var $_head_css_link_arr = array();
68
69	/**
70	* holds an array of SCRIPTtag objects
71	* in the head tag that reference an
72	* an extern javascript file.
73	* @var array
74	* @access private
75	*/
76	var $_head_js_link_arr = array();
77
78	/**
79	* character set to be used in this
80	* page. This gets automatically
81	* placed in the Content-Type
82	* META tag.
83	* @var string
84	* @access private
85	*/
86	var $_charset = "iso-8859-1";
87
88
89	/**
90	* The encoding of the XHTML
91	* XML tag
92	*/
93	var $_xml_encoding = "UTF-8";
94
95	/**
96	* BODYtag object that holds all content
97	* for the body tag.
98	* @var object
99	* @access private
100	*/
101	var $_body = NULL;
102
103	/**
104	* DOCTYPEag object that sets the document
105	* type. This gets rendered prior to <html>
106	* @var object
107	* @access private
108	*/
109	var $_doctype = NULL;
110
111	/**
112	* flag to tell the class to try and
113	* change the http headers to output
114	* document of type text, instead of
115	* html. This is helpfull for debugging.
116	* @var boolean
117	* @access private
118	*/
119	var $_text_debug = FALSE;
120
121	/**
122	* This holds a FRAMESETtag object.
123	* This is used if the person is trying
124	* to render a frameset page.
125	*
126	* @var FRAMESETtag object.
127	* @access private
128	*/
129	var $_frameset = NULL;
130
131
132	/**
133	* This holds the text used to display
134	* a body content when a browser doesn't
135	* support framesets
136	*
137	* @var string
138	* @access private
139	*/
140	var $_noframes_text = "Sorry, your browser does not support frames";
141
142
143	/**
144	* This holds the attributes for the
145	* <html> tag.
146	*
147	* @var array
148	*/
149	var $_html_attributes = array();
150
151	/**
152	* keeps track of which widgets we have
153	* automatically pulled in css for
154	*
155	* @var array
156	*/
157	var $_widget_css_auto = array();
158
159	/**
160	* keeps track of which widgets we have
161	* automatically pulled in js for
162	*
163	* @var array
164	*/
165	var $_widget_js_auto = array();
166
167
168	/**
169	* Holds the value of the indent
170	* style the user wants to render
171	* the page w/
172	*
173	* @var int
174	*/
175	var $_indent_style = 0;
176
177
178
179	/**
180	* Class Constructor
181	* @param mixed - $title Title string or TITLEtag object for the page.
182	* @param string - one of 3 types of html to render. Setting this will
183	* make the object declare the gobal define which tells
184	* all of the tag objects what type of html tags to render.
185	* some tags support special features. such as the <IMG>
186	* tag. If xhtml is selected, the the IMGtag object and all
187	* utility functions will not render "border=0" as a default
188	* attribute, since this is not proper xhtml.
189	* "html" - HTML 4.0 (default)
190	* "xhtml_transitional" - render xhtml instead of html
191	* - doctype is XHTML transitional.
192	* "xhtml_strict" - render xhtml instead of html 4.0.
193	* - doctype is XHTML strict.
194	* @param int - one of 2 types. INDENT_NICE or INDENT_LEFT_JUSTIFY
195	* This tells the page how to render the indenting of the
196	* output. By default it is set to INDENT_NICE, which nicely
197	* indents each nested tag. You can have all tags rendered
198	* left justified (smaller size in output) by using
199	* INDENT_LEFT_JUSTIFY
200	*
201	* @access public
202	*/
203	function HTMLPageClass($title=NULL, $html_type=HTML, $indent_style=INDENT_NICE) {
204
205	switch ($html_type) {
206	case HTML:
207	default:
208	$this->build_doctype("-//W3C//DTD HTML 4.01 Transitional//EN");
209	$GLOBALS["HTML_RENDER_TYPE"] = HTML;
210	break;
211
212	case XHTML_STRICT:
213	$this->build_doctype("-//W3C//DTD XHTML 1.0 Strict//EN",
214	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd");
215	$GLOBALS["HTML_RENDER_TYPE"] = XHTML_STRICT;
216	$this->set_html_attributes( array( "xmlns" => "http://www.w3.org/1999/xhtml",
217	"xml:lang" => "en",
218	"lang" => "en") );
219	break;
220
221	case XHTML:
222	case XHTML_TRANSITIONAL:
223	$this->build_doctype("-//W3C//DTD XHTML 1.0 Transitional//EN",
224	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd");
225	$GLOBALS["HTML_RENDER_TYPE"] = XHTML;
226	$this->set_html_attributes( array( "xmlns" => "http://www.w3.org/1999/xhtml",
227	"xml:lang" => "en",
228	"lang" => "en") );
229	break;
230
231	//What else needs to be done to properly support
232	//XHTML frameset? TODO LIST for 1.1
233	case XHTML_FRAMESET:
234	$this->build_doctype("-//W3C//DTD XHTML 1.0 Frameset//EN",
235	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd");
236	$GLOBALS["HTML_RENDER_TYPE"] = XHTML_FRAMESET;
237	break;
238	}
239
240	$this->_head = new HEADtag;
241	$this->_head_js = html_script();
242	$this->_head_style = html_style();
243	$this->_create_body();
244	if ($title != NULL) {
245	$this->set_title( $title );
246	}
247
248	$this->_indent_style = $indent_style;
249	}
250
251	//**************************************************
252	//* HEAD tag related functions
253	//**************************************************
254
255
256	/**
257	* this adds content to the head tag
258	* of the page
259	*
260	* @param mixed - any content to add
261	*/
262	function add_head_content( ) {
263	$num_args = func_num_args();
264	for ($i=0;$i<$num_args;$i++) {
265	$this->_head->add(func_get_arg($i));
266	}
267	}
268
269	/**
270	* Same ass add_head_content()
271	*
272	* @deprecated - use add_head_content();
273	*/
274	function push_head_content( ) {
275	$args = func_get_args();
276	call_user_func_array( array(&$this, "add_head_content"), $args);
277	}
278
279
280	/**
281	* adds raw javascript to the head which
282	* will automatically get wrapped in a
283	* <script language="JavaScript"> tag.
284	* @param mixed $content - raw javascript code to add to the head
285	*/
286	function add_head_js( $content ) {
287	$this->_head_js->push( $content );
288	}
289
290	/**
291	* Same ass add_head_js()
292	*
293	* @deprecated - use add_head_js();
294	*/
295	function push_head_js( $content ) {
296	$this->add_head_js( $content );
297	}
298
299	/**
300	* this function adds raw css to the
301	* <head> tag. It will automatically
302	* be wrapped in a <style type="text/css">
303	*
304	* @param string - the raw css
305	*/
306	function add_head_css( $css ) {
307	$this->_head_style->push( $css );
308	}
309
310	/**
311	* set the title of the page output.
312	* @param mixed $title - the title of the html page
313	* can be TITLEtag object.
314	*
315	*/
316	function set_title( $title ) {
317	if (is_object($title)) {
318	if ($title->_tag == "title") {
319	$this->_title = $title;
320	} else {
321	//they did something funky here.
322	return -1;
323	}
324	} else {
325	$this->_title = html_title( $title );
326	}
327	}
328
329	/**
330	* pushes a css external reference to the head area
331	* @param mixed $link - link tag object or $url for a css.
332	*/
333	function add_css_link( $link ) {
334	if (is_object($link)) {
335	$css = $link;
336	} else {
337	$css = html_link($link, "stylesheet", "text/css");
338	}
339	$this->_head_css_link_arr[] = $css;
340	}
341
342	/**
343	* Same ass add_css_link()
344	*
345	* @deprecated - use add_css_link();
346	*/
347	function push_css_link( $link ) {
348	$this->add_css_link( $link );
349
350	}
351
352	/**
353	* This adds a link to an external Javascript
354	* file, which will get rendered in the head.
355	*
356	* @param mixed $link - script tag object or $url of .js file.
357	*/
358	function add_js_link( $link ) {
359	if (is_object($link)) {
360	$js = $link;
361	} else {
362	$js = html_script($link);
363	}
364	$this->_head_js_link_arr[] = $js;
365	}
366
367	/**
368	* same as add_js_link()
369	*
370	* @deprecated
371	*/
372	function push_js_link( $link ) {
373	$this->add_js_link( $link );
374	}
375
376	/**
377	* Automatically set a page meta tag refresh
378	* @param int $time - time in seconds to refresh
379	* @param string $url - the url to go to.
380	*/
381	function set_refresh( $time, $url=NULL ) {
382	if ($url) {
383	$time .= ";url=$url";
384	}
385	$this->push_head_content( html_meta($time, "refresh") );
386	}
387
388	/**
389	* set the character set
390	* @param string $charset - the charset for the meta tag
391	*
392	*/
393	function set_charset( $charset ) {
394	$this->_charset = $charset;
395	}
396
397	/**
398	* This sets the encoding type for
399	* XHTML documents
400	*
401	* @param string - the encoding parameter
402	*/
403	function set_encoding( $encoding ) {
404	$this->_xml_encoding = $encoding;
405	}
406
407	/**
408	* This method sets the lang, and xml:lang
409	* setting in the HTML tag.
410	*
411	* @param string - the language
412	*/
413	function set_language( $language ) {
414	$this->_html_attributes["xml:lang"] = $language;
415	$this->_html_attributes["lang"] = $language;
416	}
417
418	/**
419	* This function is used to set the FRAMSETtag
420	* object for this page. This automatically
421	* sets the output for this page object to
422	* be a frameset.
423	*
424	* @param FRAMESETtag object - $frameset
425	*/
426	function set_frameset( $frameset ) {
427	if (is_object($frameset)) {
428	if ($frameset->get_tag() == "frameset") {
429	$this->_frameset = $frameset;
430	}
431	}
432	}
433
434
435	/**
436	* This function returns the
437	* attributes to be used for the
438	* <html> tag.
439	*
440	* @return array();
441	*/
442	function get_html_attributes() {
443	return $this->_html_attributes;
444	}
445
446	/**
447	* This function sets the attributes
448	* for the <html> tag
449	*
450	* @param array - the name=>value
451	* pair for the
452	* attributes
453	*/
454	function set_html_attributes( $attributes ) {
455	$this->_html_attributes = $attributes;
456	}
457
458
459	/**
460	* this builds the content type meta tag.
461	*
462	*/
463	function _build_content_type_tag() {
464	$content_type = "text/html; charset=" . $this->_charset;
465	return html_meta($content_type, "Content-Type");
466	}
467
468	//**************************************************
469	//* BODY tag related functions
470	//**************************************************
471
472
473	/**
474	* This function adds content to the <body>
475	* area of the page.
476	*
477	* @param mixed - any # of parameters
478	*/
479	function add() {
480	$num_args = func_num_args();
481	for ($i=0;$i<$num_args;$i++) {
482	$arg = func_get_arg($i);
483	//see if the arg is an object
484	//and a child of BaseWidget.
485	if (is_object($arg) && is_subclass_of( $arg, "basewidget")) {
486	//see if they have an js they need to include
487	$js = "";
488	$js = $arg->get_javascript();
489	$class_name = get_class($arg);
490	if ($js != "" && !$this->_widget_js_auto[$class_name]) {
491	$this->add_head_js( str_replace(chr(9),'', $js) );
492	$this->_widget_js_auto[$class_name] = TRUE;
493	}
494	}
495	$this->_body->add(func_get_arg($i));
496	}
497	}
498
499	/**
500	* Same as add()
501	*
502	* @deprecated - use add()
503	*
504	*/
505	function push( ) {
506	$args = func_get_args();
507	call_user_func_array( array(&$this, "add"), $args);
508	}
509
510	/**
511	* Adds the content reference to the <body>
512	* tag for later use.
513	*
514	* @param mixed $content - content to add
515	*/
516	function add_reference( &$content ) {
517	$this->_body->push_reference( $content );
518	}
519
520	/**
521	* Same as add()
522	*
523	* @deprecated - use add()
524	*
525	*/
526	function push_reference( &$content ) {
527	$this->add_reference( $content );
528	}
529
530	/**
531	* This is responsible for creating the
532	* BODYtag object. We only will
533	* create a new $this->_body if it doesn't
534	* already exist.
535	*
536	*/
537	function _create_body() {
538	if ($this->_body == NULL) {
539	$this->_body = new BODYtag;
540	//$this->_body->add( " " );
541	}
542	}
543
544	/**
545	* set attributes of body tag
546	* @param array $attributes the name=>value pairs
547	*
548	*/
549	function set_body_attributes( $attributes ) {
550	if (!is_object( $this->_body )) {
551	$this->_create_body();
552	}
553	$this->_body->set_tag_attributes( $attributes );
554	}
555
556	/**
557	* This function is used to build the DOCTYPE
558	* tag for the page. It will automatically
559	* create a DOCTYPE with a document_element of "html"
560	* and a source of "PUBLIC"
561	*
562	* @param string - link1
563	* @param string - link2
564	*/
565	function build_doctype($link1, $link2=NULL) {
566	$this->_doctype = xml_doctype("html", "PUBLIC", $link1, $link2);
567	}
568
569	//**************************************************
570	//* General functions
571	//**************************************************
572
573	/**
574	* set the $_text_debug flag
575	* @param $flag - boolean.
576	*/
577	function set_text_debug( $flag ) {
578	$this->_text_debug = $flag;
579	}
580
581
582	//**************************************************
583	//* RENDERING of content related functions
584	//**************************************************
585
586	/**
587	* builds the head object and its content.
588	*
589	*/
590	function _build_head() {
591
592	$this->_head->add( $this->_build_content_type_tag() );
593
594	if ($this->_title) {
595	$this->_head->add( $this->_title );
596	}
597
598	if ( $this->_head_style->count_content() ) {
599	$this->_head->add( $this->_head_style );
600	}
601	if ( $this->_head_js->count_content() ) {
602	$this->_head->add( $this->_head_js );
603	}
604
605	if (count($this->_head_css_link_arr)) {
606	foreach( $this->_head_css_link_arr as $css) {
607	$this->_head->add( $css );
608	}
609	}
610
611	if (count($this->_head_js_link_arr)) {
612	foreach( $this->_head_js_link_arr as $js) {
613	$this->_head->add( $js );
614	}
615	}
616	}
617
618	/**
619	* This builds a frameset body tag
620	* wrapped in a <noframes> tag.
621	*
622	* @return NOFRAMEStag object.
623	*/
624	function _frameset_wrap_body() {
625	$noframes = new NOFRAMEStag;
626	$body = new BODYtag;
627	$body->add( $this->_noframes_text );
628	$noframes->add( $body );
629	return $noframes;
630	}
631
632	/**
633	* render the page.
634	*
635	*
636	* @return string the raw html output.
637	*/
638	function render() {
639
640	//lets use ourself to render the debug page!
641	if ($this->_text_debug) {
642	$page = new HTMLPageClass;
643	$page->add_css_link("/phphtmllib/css/HTMLPageClass.css");
644	}
645
646	$newline = " ";
647	$attributes = $this->get_html_attributes();
648	$html = new HTMLtag( $attributes );
649	$html->add( $newline );
650	$this->_build_head();
651	$html->add( $this->_head );
652
653	//Check to see if we are rendering
654	//a frameset page.
655	if ($this->_frameset != NULL) {
656	//Looks like they have set the frameset
657	//member, so we are rendering a frameset
658	//we will automatically wrap the <body>
659	$html->add( $newline );
660	$html->add( $this->_frameset );
661	$html->add( $newline );
662	$html->add( $this->_frameset_wrap_body() );
663	} else {
664	$html->add( $newline );
665	//$this->_body->add( $newline );
666	$html->add( $this->_body );
667	}
668
669	$html-> add( $newline );
670
671	if ($this->_text_debug) {
672	if ($GLOBALS["HTML_RENDER_TYPE"] == XHTML_STRICT) {
673	$xml = new XMLtag(array("version" => "1.0",
674	"encoding"=>$this->_xml_encoding));
675	$page->add( $xml->render(0,1) );
676	}
677	$page->add( $this->_doctype->render(0,1) );
678	$page->add( $html->render($this->_indent_style,1) );
679	return $page->render();
680	} else {
681	$output = '';
682	if ($GLOBALS["HTML_RENDER_TYPE"] == XHTML_STRICT) {
683	$xml = new XMLtag(array("version" => "1.0",
684	"encoding"=>$this->_xml_encoding));
685	$output = $xml->render(0);
686	}
687	$output .= $this->_doctype->render();
688	$output .= $html->render($this->_indent_style);
689	return $output;
690	}
691	}
692	}
693
694
695	?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26