com.newsblob.phphtmllib/widgets/XMLDocumentClass.inc

<?php

/**
 * This contains the XMLDocumentClass
 *
 * $Id: XMLDocumentClass.inc,v 1.12 2002/11/22 21:51:08 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();
        }
        
        /**
         * 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],
                                                                                  $this->_doctype_links[1]);
                }
        }
}
?>
1	jonen	1.1	<?php
2
3			/**
4			* This contains the XMLDocumentClass
5			*
6			* $Id: XMLDocumentClass.inc,v 1.12 2002/11/22 21:51:08 hemna Exp $
7			*
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
139			/**
140			* function that will render the XML Document.
141			*
142			* @param int - the indentation level for
143			* the container.
144			* @param int - the output debug flag to
145			* maintain compatibility w/ the API.
146			*
147			* @return string the raw html output.
148			*/
149			function render( $indent_level = 0) {
150
151			//dump out the content type
152			$this->dump_http_header();
153
154			//set the encoding type
155			if ($this->_show_char_encoding) {
156			$this->_xml_obj->set_tag_attribute("encoding", $this->get_encoding() );
157			}
158
159			//add the xml tag
160			$output = $this->_xml_obj->render(0);
161
162			//add any stylesheet links
163			if ($this->_xml_stylesheet_container->count_content() > 0) {
164			$output .= $this->_xml_stylesheet_container->render(0);
165			}
166
167			//build the doctype if needed.
168			$this->_build_doctype();
169
170			if ($this->_doctype != NULL) {
171			$output .= $this->_doctype->render();
172			}
173
174			//set the root tag's attributes
175			$this->_root_tag->set_tag_attributes( $this->get_root_attributes() );
176
177			//render the root tag's content
178			$output .= $this->_root_tag->render($indent_level, 0);
179			return $output;
180			}
181
182			/**
183			* we override this class to make sure
184			* we push all content inside the
185			* local _xml_obj tag
186			*
187			* push content onto content stack
188			* adds content to tag as a FIFO.
189			* You can have n number of parameters.
190			* each one will get added in succession to the content.
191			* @param mixed $content - either string, or tag object.
192			* @access public
193			*/
194			function add() {
195			if ($this->_root_tag == NULL) {
196			$this->_build_root_tag();
197			}
198			$args = func_get_args();
199			$num = func_num_args();
200			foreach( $args as $content) {
201			$this->_root_tag->push( $content );
202			}
203			}
204
205			/**
206			* Same as add().
207			* NOTE: only exists for 1.1.x compatibility
208			*
209			* @deprecated
210			* @param mixed $content - either string, or tag object.
211			* @access public
212			*/
213			function push( ) {
214			$args = func_get_args();
215			call_user_func_array( array(&$this, "add"), $args);
216			}
217
218
219			/**
220			* we override this class to make sure
221			* we push all content inside the
222			* local _xml_obj tag
223			*
224			* push content onto content stack
225			* adds content to tag as a FIFO
226			* You can only add 1 element at a time, and
227			* it will be added as a reference. So you can't do
228			* push_reference("something");, since "something" is a
229			* static.
230			* @param mixed $content - either string, or tag object.
231			* the tag object gets stored as a
232			* reference to the original, so you
233			* can push it, then modify it later.
234			* @access public
235			*/
236			function add_reference( &$content ) {
237			if ($this->_root_tag == NULL) {
238			$this->_build_root_tag();
239			}
240			$this->_root_tag->add_reference( $content );
241			}
242
243			/**
244			* Same as add_reference
245			* NOTE : only exists for compatibility with 1.1.x
246			*
247			* @deprecated
248			*
249			* @access public
250			* @param mixed - a reference to some variable.
251			*/
252			function push_reference( &$content ) {
253			$this->add_reference( $content );
254			}
255
256			/**
257			* This function is used to add a new
258			* xml-stylesheet tag to the top
259			* portion of the document.
260			* This will automatically get added
261			* after the xml tag and before the
262			* <!DOCTYPE > tag
263			*
264			* @param string - the href for the stylesheet link
265			*/
266			function add_xml_stylesheet_link( $href ) {
267			$this->_xml_stylesheet_container->add( xml_stylesheet($href) );
268			}
269
270			/**
271			* This function builds the _xml_stylesheet_container
272			*
273			*/
274			function _build_xml_stylesheet_container() {
275			$this->_xml_stylesheet_container = container();
276			}
277
278
279			/**
280			* we override this class to make sure
281			* we push all content inside the
282			* local _xml_obj tag
283			*
284			* destroy existing content and start with new content.
285			* @param mixed $content can be tag object, or raw (string).
286			* @access public
287			*/
288			function reset_content( ) {
289			$this->_build_root_tag();
290			}
291
292
293			/**
294			* This function builds the local
295			* xml container object that holds
296			* all xml tags that are pushed into
297			* this class
298			*
299			* @return XMLtag object
300			*/
301			function _create_xml_obj() {
302			$this->_xml_obj = &new XMLtag( array("version" => "1.0") );
303			}
304
305			/**
306			* This function builds the root xml
307			* tag that will contain all of the Document's
308			* xml tags
309			*
310			*/
311			function _build_root_tag() {
312			$this->_root_tag = xml_tag($this->_root_name);
313			}
314
315			/**
316			* set the character set
317			* @param string $charset - the charset for the meta tag
318			*
319			*/
320			function set_encoding( $charset ) {
321			$this->_charset = $charset;
322			}
323
324			/**
325			* This function gets the current encoding type
326			*
327			* @return string - the current encoding type
328			* for the xml
329			*/
330			function get_encoding() {
331			return $this->_charset;
332			}
333
334			/**
335			* Set the document name
336			* and the root tag's name.
337			* @param string $doc_name
338			*
339			*/
340			function set_root_name($root_name) {
341			$this->_root_name = $root_name;
342			}
343
344			/**
345			* This function gets the document name
346			*
347			* @return string - the current document name
348			* for the xml
349			*/
350			function get_root_name() {
351			return $this->_root_name;
352			}
353
354			/**
355			* This function is used to set the
356			* root xml tag's attributes
357			*
358			* @param array
359			*/
360			function set_root_attributes( $attributes ) {
361			$this->_root_attributes = $attributes;
362			}
363
364			/**
365			* This sets 1 root tag attribute value pair
366			*
367			* @param string - the attribute name
368			* @param string - the attribute value
369			*/
370			function set_root_attribute( $name, $value ) {
371			$this->_root_attributes[$name] = $value;
372			}
373
374			/**
375			* This function is used to get the
376			* root xml tag's attributes
377			*
378			* @return array
379			*/
380			function get_root_attributes() {
381			return $this->_root_attributes;
382			}
383
384			/**
385			* This method is used to set the link attributes
386			* for the DOCTYPE tag
387			*
388			*/
389			function set_doctype_link( $link ) {
390			if ($link != NULL) {
391			$this->_doctype_links[] = $link;
392			}
393			}
394
395			/**
396			* method to update the flag that lets us know
397			* to show/render the character encoding string
398			* in the xml tag or not
399			*
400			* @param boolean
401			*/
402			function show_character_encoding( $flag=TRUE) {
403			$this->_show_char_encoding = $flag;
404			}
405
406			/**
407			* this function is used to set the flag
408			* that tells this class to automatically
409			* output the content type in the http header
410			*
411			* @param boolean
412			*/
413			function show_http_header( $flag=TRUE ) {
414			$this->_show_http_header = $flag;
415			}
416
417			/**
418			* This function is used to set the
419			* http header content-type for output to browsers
420			*
421			* @param string
422			*/
423			function set_http_content_type( $type="application/xml") {
424			$this->_http_content_type = $type;
425			}
426
427			/**
428			* This function returns the current
429			* value of the http header content type
430			*
431			* @return string
432			*/
433			function get_http_content_type() {
434			return $this->_http_content_type;
435			}
436
437			/**
438			* This function is used to output the http
439			* header for this document.
440			* It makes a call to php's Header() to
441			* set the Content-type
442			*
443			*/
444			function dump_http_header() {
445			if ($this->_show_http_header) {
446			Header("Content-type: ".$this->_http_content_type);
447			}
448			}
449
450			/**
451			* this function is used to change the
452			* DOCTYPE tag's source attribute. By
453			* default it is set to SYSTEM.
454			* (ie <!DOCTYPE html SYSTEM > )
455			* ^^^^^^
456			*
457			* NOTE: only 2 valid values 'SYSTEM', 'PUBLIC'
458			*
459			* @param string - the new source attribute
460			*/
461			function set_doctype_source($source) {
462			if (strcmp("PUBLIC", $source) != 0 &&
463			strcmp("SYSTEM", $source) != 0) {
464			//user tried to set it to an invalid
465			//value.
466			trigger_error("XMLDocumentClass::set_doctype_source() ".
467			"invalid source type of (".$source.") set. ",
468			E_USER_WARNING);
469			} else {
470			$this->_doctype_source = $source;
471			}
472			}
473
474			/**
475			* This function returns the current
476			* DOCTYPE tag's source attribute
477			*
478			* @return string
479			*/
480			function get_doctype_source() {
481			return $this->_doctype_source;
482			}
483
484
485			/**
486			* This method builds the DOCTYPE tag for the document
487			*
488			*/
489			function _build_doctype() {
490			if (count($this->_doctype_links) > 0) {
491			$this->_doctype = xml_doctype($this->get_root_name(),
492			$this->get_doctype_source(),
493			$this->_doctype_links[0],
494			$this->_doctype_links[1]);
495			}
496			}
497			}
498			?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26