widgets/xml/XMLDocumentClass.inc

<?php

/**
 * This contains the XMLDocumentClass
 *
 * $Id: XMLDocumentClass.inc,v 1.3 2003/10/02 23:38:16 hemna Exp $
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @package phpHtmlLib
 * 
 */


/**
 *
 * This class lets you build a complete
 * xml document and render it.
 *
 * It automatically creates the root xml tag
 * that will contain all of the content.
 * The name of the tag is the first parameter to
 * the constructor.  You can add/change the attributes
 * to the root tag via the set_root_attributes() or
 * the set_root_attribute() methods.
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @package phpHtmlLib 
 */ 
class XMLDocumentClass extends Container {


        /**
         * holds the xml tag object that
         * all content will be wrapped in
         *
         */
        var $_xml_obj = NULL;

        /**
     * character set to be used in this
     * page.  This gets automatically
     * placed in the <?xml encoding="" ?>
     * @var  string
     * @access   private
     */
    var $_charset = "iso-8859-1";

        /**
         * This flag tells if we should
         * output the header content type.
         * this is usefull for folks using
         * this class for output not destined
         * for a browser.
         */
        var $_show_http_header = FALSE;

        /**
         * this is a hack to show the
         * character encoding or not.
         * DEFAULT: on
         *
         * @var boolean
         */
        var $_show_char_encoding = TRUE;

    /**
     * Holds the url of dtd
     */
    var $dtd = NULL;

    /**
     * Holds the name of the root xml
         * element as well as the DOCTYPE
         * document_element attribute
     */
    var $root_name = NULL;

        /**
         * The root xml tag for all data
         *
         * @var XMLTagClass object
         */
        var $_root_tag = NULL;

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

        /**
         * the DOCTYPE source attribute
         *
         * @var string
         */
        var $_doctype_source = "SYSTEM";

        /**
         * This contains the doctype links
         * attributes.  There can be a maximum
         * of 2 according to the XML spec
         */
        var $_doctype_links = array();

        /**
         * The http content-type
         *
         */
        var $_http_content_type = "application/xml";

        /**
         * The container for all the
         * xml-stylesheet tags
         *
         * @var object
         */
        var $_xml_stylesheet_container = NULL;


        /**
         * The constructor
         *
         * @param string - the root xml tag's name
         * @param string - the link path to the DTD (if any)
         * @param array - the root tag's attributes
         *
         */
        function XMLDocumentClass($root_name, $dtd = NULL, $root_attributes = array()) {
                $this->_create_xml_obj();
        $this->set_root_name($root_name);
                $this->set_doctype_link( $dtd );
                $this->set_root_attributes( $root_attributes );
                $this->_build_root_tag();
                $this->_build_xml_stylesheet_container();

        //we should always render in 
        $GLOBALS["HTML_RENDER_TYPE"] = XHTML_STRICT;
        }
        
        /**
         * function that will render the XML Document.
         *
         * @param int - the indentation level for 
         *              the container.
         * @param int - the output debug flag to 
         *              maintain compatibility w/ the API.
         *
         * @return string the raw html output.
         */
        function render( $indent_level = 0) {

                //dump out the content type             
                $this->dump_http_header();

                //set the encoding type
                if ($this->_show_char_encoding) {
                        $this->_xml_obj->set_tag_attribute("encoding", $this->get_encoding() );
                }

                //add the xml tag
                $output = $this->_xml_obj->render(0);

                //add any stylesheet links
                if ($this->_xml_stylesheet_container->count_content() > 0) {
                        $output .= $this->_xml_stylesheet_container->render(0);
                }               

                //build the doctype if needed.
                $this->_build_doctype();

                if ($this->_doctype != NULL) {
                        $output .= $this->_doctype->render();
                }

                //set the root tag's attributes
                $this->_root_tag->set_tag_attributes( $this->get_root_attributes() );

                //render the root tag's content
                $output .= $this->_root_tag->render($indent_level, 0);
                return $output;
        }

        /**
         * we override this class to make sure
         * we push all content inside the 
         * local _xml_obj tag
         *
     * push content onto content stack
     * adds content to tag as a FIFO.
     * You can have n number of parameters.
     * each one will get added in succession to the content.
     * @param   mixed   $content - either string, or tag object.
     * @access  public
         */
        function add() {
                if ($this->_root_tag == NULL) {
                        $this->_build_root_tag();
                }
                $args = func_get_args();
                $num = func_num_args();
                foreach( $args as $content) {
                        $this->_root_tag->push( $content );
                }
        }

    /**
     * Same as add().
     * NOTE: only exists for 1.1.x compatibility
     * 
     * @deprecated
     * @param   mixed   $content - either string, or tag object.
     * @access  public
     */
    function push(  ) {
        $args = func_get_args();
        call_user_func_array( array(&$this, "add"), $args);
    }


        /**
         * we override this class to make sure
         * we push all content inside the 
         * local _xml_obj tag
         *
     * push content onto content stack
     * adds content to tag as a FIFO
     * You can only add 1 element at a time, and
     * it will be added as a reference.  So you can't do
     * push_reference("something");, since "something" is a
     * static.
     * @param   mixed   $content - either string, or tag object.
     *                             the tag object gets stored as a
     *                             reference to the original, so you
     *                             can push it, then modify it later.
     * @access  public
         */
        function add_reference( &$content ) {
                if ($this->_root_tag == NULL) {
                        $this->_build_root_tag();
                }
                $this->_root_tag->add_reference( $content );
        }

    /**
     * Same as add_reference
     * NOTE : only exists for compatibility with 1.1.x
     *
     * @deprecated
     * 
     * @access  public
         * @param   mixed - a reference to some variable.
     */
    function push_reference( &$content ) {
        $this->add_reference( $content );
    }

        /**
         * This function is used to add a new
         * xml-stylesheet tag to the top 
         * portion of the document.
         * This will automatically get added 
         * after the xml tag and before the
         * <!DOCTYPE > tag
         *
         * @param string - the href for the stylesheet link
         */
        function add_xml_stylesheet_link( $href ) {
                $this->_xml_stylesheet_container->add( xml_stylesheet($href) );
        }

        /**
         * This function builds the _xml_stylesheet_container
         *
         */
        function _build_xml_stylesheet_container() {
                $this->_xml_stylesheet_container = container();
        }


        /**
         * we override this class to make sure
         * we push all content inside the 
         * local _xml_obj tag
         *
     * destroy existing content and start with new content.
     * @param   mixed   $content    can be tag object, or raw (string).
     * @access  public
     */
    function reset_content( ) {
        $this->_build_root_tag();
    }


        /**
         * This function builds the local
         * xml container object that holds
         * all xml tags that are pushed into
         * this class
         *
         * @return XMLtag object
         */
        function _create_xml_obj() {
                $this->_xml_obj = &new XMLtag( array("version" => "1.0") );
        }

        /**
         * This function builds the root xml
         * tag that will contain all of the Document's
         * xml tags
         *
         */
        function _build_root_tag() {
                $this->_root_tag = xml_tag($this->_root_name);
        }

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

        /**
         * This function gets the current encoding type
         *
         * @return string - the current encoding type
         *                  for the xml
         */
        function get_encoding() {
                return $this->_charset;
        }

    /**
     * Set the document name
         * and the root tag's name.
     * @param string  $doc_name
     *
     */
    function set_root_name($root_name) {
        $this->_root_name = $root_name;
    }

     /**
     * This function gets the document name
     *
     * @return string - the current document name
     *                  for the xml
     */
    function get_root_name() {
        return $this->_root_name;
    }

        /**
         * This function is used to set the
         * root xml tag's attributes
         *
         * @param array
         */
        function set_root_attributes( $attributes ) {
        $this->_root_attributes = $attributes;
        }

        /**
         * This sets 1 root tag attribute value pair
         *
         * @param string - the attribute name
         * @param string - the attribute value
         */
        function set_root_attribute( $name, $value ) {
                $this->_root_attributes[$name] = $value;
        }

        /**
         * This function is used to get the
         * root xml tag's attributes
         *
         * @return array
         */
        function get_root_attributes() {
                return $this->_root_attributes;
        }

        /**
         * This method is used to set the link attributes
         * for the DOCTYPE tag
         *
         */
        function set_doctype_link( $link ) {
                if ($link != NULL) {
                        $this->_doctype_links[] = $link;
                }               
        }

        /**
         * method to update the flag that lets us know
         * to show/render the character encoding string
         * in the xml tag or not
         *
         * @param boolean
         */
        function show_character_encoding( $flag=TRUE) {
                $this->_show_char_encoding = $flag;
        }

    /**
     * this function is used to set the flag
     * that tells this class to automatically
     * output the content type in the http header
     *
     * @param boolean
     */
    function show_http_header( $flag=TRUE ) {
        $this->_show_http_header = $flag;
    }

        /**
         * This function is used to set the 
         * http header content-type for output to browsers
         *
         * @param string 
         */
        function set_http_content_type( $type="application/xml") {
                $this->_http_content_type = $type;
        }

        /**
         * This function returns the current 
         * value of the http header content type
         *
         * @return string
         */
        function get_http_content_type() {
                return $this->_http_content_type;
        }

        /**
         * This function is used to output the http
         * header for this document.
         * It makes a call to php's Header() to 
         * set the Content-type
         *
         */
        function dump_http_header() {
                if ($this->_show_http_header) {
                        Header("Content-type: ".$this->_http_content_type);
                }
        }

        /**
         * this function is used to change the 
         * DOCTYPE tag's source attribute.  By 
         * default it is set to SYSTEM.
         * (ie <!DOCTYPE html SYSTEM > )
         *                    ^^^^^^
         *
         * NOTE: only 2 valid values 'SYSTEM', 'PUBLIC'
         *
         * @param string - the new source attribute
         */
        function set_doctype_source($source) {
                if (strcmp("PUBLIC", $source) != 0 &&
                        strcmp("SYSTEM", $source) != 0) {
                        //user tried to set it to an invalid
                        //value.
                        trigger_error("XMLDocumentClass::set_doctype_source() ".
                                                  "invalid source type of (".$source.") set. ",
                                                  E_USER_WARNING);
                } else {
                        $this->_doctype_source = $source;
                }
        }

        /**
         * This function returns the current
         * DOCTYPE tag's source attribute
         *
         * @return string
         */
        function get_doctype_source() {
                return $this->_doctype_source;
        }


        /**
         * This method builds the DOCTYPE tag for the document
         *
         */
        function _build_doctype() {
                if (count($this->_doctype_links) > 0) {
                        $this->_doctype = xml_doctype($this->get_root_name(),
                                                                                  $this->get_doctype_source(),
                                                                                  $this->_doctype_links[0],
                                                                                  count($this->_doctype_links) > 1 ? $this->_doctype_links[1] : NULL);
                }
        }
}
?>
1	jonen	1.1	<?php
2
3			/**
4			* This contains the XMLDocumentClass
5			*
6	jonen	1.2	* $Id: XMLDocumentClass.inc,v 1.3 2003/10/02 23:38:16 hemna Exp $
7	jonen	1.1	*
8			* @author Walter A. Boring IV <waboring@buildabetterweb.com>
9			* @package phpHtmlLib
10			*
11			*/
12
13
14			/**
15			*
16			* This class lets you build a complete
17			* xml document and render it.
18			*
19			* It automatically creates the root xml tag
20			* that will contain all of the content.
21			* The name of the tag is the first parameter to
22			* the constructor. You can add/change the attributes
23			* to the root tag via the set_root_attributes() or
24			* the set_root_attribute() methods.
25			*
26			* @author Walter A. Boring IV <waboring@buildabetterweb.com>
27			* @package phpHtmlLib
28			*/
29			class XMLDocumentClass extends Container {
30
31
32			/**
33			* holds the xml tag object that
34			* all content will be wrapped in
35			*
36			*/
37			var $_xml_obj = NULL;
38
39			/**
40			* character set to be used in this
41			* page. This gets automatically
42			* placed in the <?xml encoding="" ?>
43			* @var string
44			* @access private
45			*/
46			var $_charset = "iso-8859-1";
47
48			/**
49			* This flag tells if we should
50			* output the header content type.
51			* this is usefull for folks using
52			* this class for output not destined
53			* for a browser.
54			*/
55			var $_show_http_header = FALSE;
56
57			/**
58			* this is a hack to show the
59			* character encoding or not.
60			* DEFAULT: on
61			*
62			* @var boolean
63			*/
64			var $_show_char_encoding = TRUE;
65
66			/**
67			* Holds the url of dtd
68			*/
69			var $dtd = NULL;
70
71			/**
72			* Holds the name of the root xml
73			* element as well as the DOCTYPE
74			* document_element attribute
75			*/
76			var $root_name = NULL;
77
78			/**
79			* The root xml tag for all data
80			*
81			* @var XMLTagClass object
82			*/
83			var $_root_tag = NULL;
84
85			/**
86			* DOCTYPEag object that sets the document
87			* type. This gets rendered prior to <html>
88			* @var object
89			* @access private
90			*/
91			var $_doctype = NULL;
92
93			/**
94			* the DOCTYPE source attribute
95			*
96			* @var string
97			*/
98			var $_doctype_source = "SYSTEM";
99
100			/**
101			* This contains the doctype links
102			* attributes. There can be a maximum
103			* of 2 according to the XML spec
104			*/
105			var $_doctype_links = array();
106
107			/**
108			* The http content-type
109			*
110			*/
111			var $_http_content_type = "application/xml";
112
113			/**
114			* The container for all the
115			* xml-stylesheet tags
116			*
117			* @var object
118			*/
119			var $_xml_stylesheet_container = NULL;
120
121
122			/**
123			* The constructor
124			*
125			* @param string - the root xml tag's name
126			* @param string - the link path to the DTD (if any)
127			* @param array - the root tag's attributes
128			*
129			*/
130			function XMLDocumentClass($root_name, $dtd = NULL, $root_attributes = array()) {
131			$this->_create_xml_obj();
132			$this->set_root_name($root_name);
133			$this->set_doctype_link( $dtd );
134			$this->set_root_attributes( $root_attributes );
135			$this->_build_root_tag();
136			$this->_build_xml_stylesheet_container();
137
138			//we should always render in
139			$GLOBALS["HTML_RENDER_TYPE"] = XHTML_STRICT;
140			}
141
142			/**
143			* function that will render the XML Document.
144			*
145			* @param int - the indentation level for
146			* the container.
147			* @param int - the output debug flag to
148			* maintain compatibility w/ the API.
149			*
150			* @return string the raw html output.
151			*/
152			function render( $indent_level = 0) {
153
154			//dump out the content type
155			$this->dump_http_header();
156
157			//set the encoding type
158			if ($this->_show_char_encoding) {
159			$this->_xml_obj->set_tag_attribute("encoding", $this->get_encoding() );
160			}
161
162			//add the xml tag
163			$output = $this->_xml_obj->render(0);
164
165			//add any stylesheet links
166			if ($this->_xml_stylesheet_container->count_content() > 0) {
167			$output .= $this->_xml_stylesheet_container->render(0);
168			}
169
170			//build the doctype if needed.
171			$this->_build_doctype();
172
173			if ($this->_doctype != NULL) {
174			$output .= $this->_doctype->render();
175			}
176
177			//set the root tag's attributes
178			$this->_root_tag->set_tag_attributes( $this->get_root_attributes() );
179
180			//render the root tag's content
181			$output .= $this->_root_tag->render($indent_level, 0);
182			return $output;
183			}
184
185			/**
186			* we override this class to make sure
187			* we push all content inside the
188			* local _xml_obj tag
189			*
190			* push content onto content stack
191			* adds content to tag as a FIFO.
192			* You can have n number of parameters.
193			* each one will get added in succession to the content.
194			* @param mixed $content - either string, or tag object.
195			* @access public
196			*/
197			function add() {
198			if ($this->_root_tag == NULL) {
199			$this->_build_root_tag();
200			}
201			$args = func_get_args();
202			$num = func_num_args();
203			foreach( $args as $content) {
204			$this->_root_tag->push( $content );
205			}
206			}
207
208			/**
209			* Same as add().
210			* NOTE: only exists for 1.1.x compatibility
211			*
212			* @deprecated
213			* @param mixed $content - either string, or tag object.
214			* @access public
215			*/
216			function push( ) {
217			$args = func_get_args();
218			call_user_func_array( array(&$this, "add"), $args);
219			}
220
221
222			/**
223			* we override this class to make sure
224			* we push all content inside the
225			* local _xml_obj tag
226			*
227			* push content onto content stack
228			* adds content to tag as a FIFO
229			* You can only add 1 element at a time, and
230			* it will be added as a reference. So you can't do
231			* push_reference("something");, since "something" is a
232			* static.
233			* @param mixed $content - either string, or tag object.
234			* the tag object gets stored as a
235			* reference to the original, so you
236			* can push it, then modify it later.
237			* @access public
238			*/
239			function add_reference( &$content ) {
240			if ($this->_root_tag == NULL) {
241			$this->_build_root_tag();
242			}
243			$this->_root_tag->add_reference( $content );
244			}
245
246			/**
247			* Same as add_reference
248			* NOTE : only exists for compatibility with 1.1.x
249			*
250			* @deprecated
251			*
252			* @access public
253			* @param mixed - a reference to some variable.
254			*/
255			function push_reference( &$content ) {
256			$this->add_reference( $content );
257			}
258
259			/**
260			* This function is used to add a new
261			* xml-stylesheet tag to the top
262			* portion of the document.
263			* This will automatically get added
264			* after the xml tag and before the
265			* <!DOCTYPE > tag
266			*
267			* @param string - the href for the stylesheet link
268			*/
269			function add_xml_stylesheet_link( $href ) {
270			$this->_xml_stylesheet_container->add( xml_stylesheet($href) );
271			}
272
273			/**
274			* This function builds the _xml_stylesheet_container
275			*
276			*/
277			function _build_xml_stylesheet_container() {
278			$this->_xml_stylesheet_container = container();
279			}
280
281
282			/**
283			* we override this class to make sure
284			* we push all content inside the
285			* local _xml_obj tag
286			*
287			* destroy existing content and start with new content.
288			* @param mixed $content can be tag object, or raw (string).
289			* @access public
290			*/
291			function reset_content( ) {
292			$this->_build_root_tag();
293			}
294
295
296			/**
297			* This function builds the local
298			* xml container object that holds
299			* all xml tags that are pushed into
300			* this class
301			*
302			* @return XMLtag object
303			*/
304			function _create_xml_obj() {
305			$this->_xml_obj = &new XMLtag( array("version" => "1.0") );
306			}
307
308			/**
309			* This function builds the root xml
310			* tag that will contain all of the Document's
311			* xml tags
312			*
313			*/
314			function _build_root_tag() {
315			$this->_root_tag = xml_tag($this->_root_name);
316			}
317
318			/**
319			* set the character set
320			* @param string $charset - the charset for the meta tag
321			*
322			*/
323			function set_encoding( $charset ) {
324			$this->_charset = $charset;
325			}
326
327			/**
328			* This function gets the current encoding type
329			*
330			* @return string - the current encoding type
331			* for the xml
332			*/
333			function get_encoding() {
334			return $this->_charset;
335			}
336
337			/**
338			* Set the document name
339			* and the root tag's name.
340			* @param string $doc_name
341			*
342			*/
343			function set_root_name($root_name) {
344			$this->_root_name = $root_name;
345			}
346
347			/**
348			* This function gets the document name
349			*
350			* @return string - the current document name
351			* for the xml
352			*/
353			function get_root_name() {
354			return $this->_root_name;
355			}
356
357			/**
358			* This function is used to set the
359			* root xml tag's attributes
360			*
361			* @param array
362			*/
363			function set_root_attributes( $attributes ) {
364			$this->_root_attributes = $attributes;
365			}
366
367			/**
368			* This sets 1 root tag attribute value pair
369			*
370			* @param string - the attribute name
371			* @param string - the attribute value
372			*/
373			function set_root_attribute( $name, $value ) {
374			$this->_root_attributes[$name] = $value;
375			}
376
377			/**
378			* This function is used to get the
379			* root xml tag's attributes
380			*
381			* @return array
382			*/
383			function get_root_attributes() {
384			return $this->_root_attributes;
385			}
386
387			/**
388			* This method is used to set the link attributes
389			* for the DOCTYPE tag
390			*
391			*/
392			function set_doctype_link( $link ) {
393			if ($link != NULL) {
394			$this->_doctype_links[] = $link;
395			}
396			}
397
398			/**
399			* method to update the flag that lets us know
400			* to show/render the character encoding string
401			* in the xml tag or not
402			*
403			* @param boolean
404			*/
405			function show_character_encoding( $flag=TRUE) {
406			$this->_show_char_encoding = $flag;
407			}
408
409			/**
410			* this function is used to set the flag
411			* that tells this class to automatically
412			* output the content type in the http header
413			*
414			* @param boolean
415			*/
416			function show_http_header( $flag=TRUE ) {
417			$this->_show_http_header = $flag;
418			}
419
420			/**
421			* This function is used to set the
422			* http header content-type for output to browsers
423			*
424			* @param string
425			*/
426			function set_http_content_type( $type="application/xml") {
427			$this->_http_content_type = $type;
428			}
429
430			/**
431			* This function returns the current
432			* value of the http header content type
433			*
434			* @return string
435			*/
436			function get_http_content_type() {
437			return $this->_http_content_type;
438			}
439
440			/**
441			* This function is used to output the http
442			* header for this document.
443			* It makes a call to php's Header() to
444			* set the Content-type
445			*
446			*/
447			function dump_http_header() {
448			if ($this->_show_http_header) {
449			Header("Content-type: ".$this->_http_content_type);
450			}
451			}
452
453			/**
454			* this function is used to change the
455			* DOCTYPE tag's source attribute. By
456			* default it is set to SYSTEM.
457			* (ie <!DOCTYPE html SYSTEM > )
458			* ^^^^^^
459			*
460			* NOTE: only 2 valid values 'SYSTEM', 'PUBLIC'
461			*
462			* @param string - the new source attribute
463			*/
464			function set_doctype_source($source) {
465			if (strcmp("PUBLIC", $source) != 0 &&
466			strcmp("SYSTEM", $source) != 0) {
467			//user tried to set it to an invalid
468			//value.
469			trigger_error("XMLDocumentClass::set_doctype_source() ".
470			"invalid source type of (".$source.") set. ",
471			E_USER_WARNING);
472			} else {
473			$this->_doctype_source = $source;
474			}
475			}
476
477			/**
478			* This function returns the current
479			* DOCTYPE tag's source attribute
480			*
481			* @return string
482			*/
483			function get_doctype_source() {
484			return $this->_doctype_source;
485			}
486
487
488			/**
489			* This method builds the DOCTYPE tag for the document
490			*
491			*/
492			function _build_doctype() {
493			if (count($this->_doctype_links) > 0) {
494			$this->_doctype = xml_doctype($this->get_root_name(),
495			$this->get_doctype_source(),
496			$this->_doctype_links[0],
497	jonen	1.2	count($this->_doctype_links) > 1 ? $this->_doctype_links[1] : NULL);
498	jonen	1.1	}
499			}
500			}
501			?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26