libs/com.newsblob.phphtmllib/XMLTagClass.inc

<?php

/**
 * Holds the XMLTagClass
 *
 * $Id: XMLTagClass.inc,v 1.24 2002/11/16 02:26:22 hemna Exp $
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @package phpHtmlLib 
 *
 * @copyright LGPL - See LICENCE
 *
 */

/**
 * make sure we include the parent class
 */
require_once( $phphtmllib."/ContainerClass.inc" );


/**
 *
 * This class is used for building and rendering
 * an XML tag.
 *
 * This class is the base class for the
 * HTMLTagClass.
 *
 * This is part of the phphtmllib libraries
 * released under the LGPL license.
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @package phpHtmlLib
 */
class XMLTagClass extends Container {


    /**
     * Tag definition for class.
     * subclass defines this value.
     * ie var $tag = "<TABLE>";
     * @var  string
     * @access   private
     */
    var $_tag = "";

    /**
     * Tag attributes as an array
     * of name value pairs.
     * ie $attributes["cellspacing"]=2;
     * @var  array
     * @access   private
     */
    var $_attributes = array();

    /**
     * flag to render close tag or not.
     * set to FALSE if no close tag is needed
     * ie <img src=hotchick.png>
     * @var  boolean
     * @access   private
     */
    var $_close_tag_required = TRUE;

    /**
     * Flag to render content or not.
     * set to FALSE to not render content.
     * ie <img src=hotchick.png>
     * @var  boolean
     * @access   private
     */
    var $_content_required = TRUE;

    /**
     * Flag to place a newline after open tag.
     * some tags are nice to have a \n after
     * to make reading of html easier.
     * ie <table>
     * @var  boolean
     * @access   public
     */
    var $newline_after_opentag = TRUE;

    /**
     * Flag to place a newline after close tag.
     * usefull for maintaining nice output inside
     * a table
     * @var  boolean
     * @access   public
     */
    var $newline_after_closetag = TRUE;

    /**
     * Flag to tell the renderer to NEVER
     * to render the tag name in lower case
     * no matter what
     * @var boolean
     * @access private
     */
    var $_always_upper_case = FALSE;

        /**
     * Flag to tell the renderer to NEVER
     * to render the tag name in upper case
     * no matter what
     * @var boolean
     * @access private
     */
    var $_always_lower_case = FALSE;

        /**
         * Automatically wrap ALL content
         * inside the <![CDATA[ CONTENT ]]> 
         * tag
         *
         * @var boolean
         */
        var $_cdata_content_wrap = FALSE;


        /**
         * holds the tag prefix
         *
         */
        var $_tag_prefix = "<";

        /**
         * holds the tag postfix
         *
         */
        var $_tag_postfix = ">";
         

        /**
         * The constructor
         *
         * @param string - the tag name
         * @param array - the attributes array
         *                can be in name => value
         *                or just value
         * @param mixed - n items of content to
         *                add
         *
         */
        function XMLTagClass($name, $attributes=array() ) {
                $this->set_tag_name( $name );
                $this->set_tag_attributes( $attributes );

        $num_args = func_num_args();
        for ($i=2;$i<$num_args;$i++) {
            $this->add(func_get_arg($i));
        }                       
        }


        /**
         * This function is responsible
         * for rendering the tag and
         * its contents
         *
         * @param int - the current indentation
         *              level for the tag
         */
        function render( $indent_level=0 ) {
                
                //try and guess the indentation flags
                //based on the data
                $this->_prepare_flags();

                //build the open tag and its
                //attributes
                $xml = $this->_render_open_tag( $indent_level );

                //build the content or PCDATA
                $xml .= $this->_render_content( $indent_level );

                //build the close tag
                //if required.
                $xml .= $this->_render_close_tag( $indent_level );

                return $xml;
        }


        /****************************************/
        /* Some helper routines for building    */
        /* pieces of the xml tag, its                   */
        /* attributes and PCDATA                                */
        /****************************************/


        /**
         * This method sets the name of the tag
         *
         * @param string - the tag name
         */
        function set_tag_name( $name ) {
                $this->_tag = $name;
        }

        /**
         * This method gets the name of the tag
         *
         * @return string - the tag name
         */
        function get_tag_name() {
                return $this->_tag;
        }

        /**
         * This returns the tag declared for this class.
         * This should be used in favor of 
         * accessing the $this->_tag directly.
         *
         * @return string - the _tag var for this class.
         */
        function get_tag() {
                //for compatibility only
                return $this->get_tag_name();
        }

    /**
     * add a single attribute (name="value")
     * @param   string  $name   attribute name
     * @param   mixed   $value  the value.
     * @access  public
     */
    function set_tag_attribute( $name, $value=NULL ) {
        $this->_attributes[$name] = $value;
    }

    /**
     * add multiple attributes (name="value")
     * @param   array   $attributes Associative array of name="value" pairs of
     *                              tag atributes.
     *                              ie array("border"=>"0", "class"=>"hover");
     * @access  public
     */
    function set_tag_attributes( $attributes=array() ) {
        $this->_attributes = array_merge($this->_attributes, $attributes);
    }

    /**
     * clear all attributes and start with new attributes
     * @param   array   $attributes Associative array of name="value" pairs of
     *                              tag atributes.
     *                              ie array("border"=>"0", "class"=>"hover");
     * @access  public
     */
    function reset_attributes( $attributes=array() ) {
        $this->_attributes = array();
        $this->set_tag_attributes( $attributes );
    }

    /**
     * get the nth element from content array
     * @param   int   $cell   the cell to get
     * @return  mixed
     */
    function _get_element( $cell ) {
        return $this->_content[$cell];
    }


    //****************************************************************
    // Misc functions
    //****************************************************************

    /**
     * set the newline_after_opentag flag
     * @param   boolean     $flag  TRUE or FALSE
     */
    function set_newline_after_opentag( $flag ) {
        $this->newline_after_opentag = $flag;
    }

    /**
     * set the newline_after_content flag
     * @param   boolean     $flag   TRUE or FALSE
     */
    function set_newline_after_closetag( $flag ) {
        $this->newline_after_closetag = $flag;
    }

        /**
         * This function turns on the collapse flag
         *
         * @param boolean - the collapse flag
         * @param boolean - the indent flag
         *                  DEFAULT: TRUE;
         */
        function set_collapse($collapse=TRUE, $indent=TRUE) {
                $this->_collapse_flag = $collapse;

                $this->set_newline_after_opentag(FALSE);
                $this->set_indent_flag($indent);
                if ($indent) {
                        $this->set_newline_after_closetag(TRUE);
                } else {
                        $this->set_newline_after_closetag(FALSE);
                }               
        }

    /**
     * This function checks to see if
     * there is only 1 content data, and
     * its not an object, then it auto
     * sets some of the indentation flags
     *
     */
    function _prepare_flags() { 
                if ($this->_content_required) {
                        if ($this->count_content() == 1 || $this->count_content() == 0) {
                                if (!is_object($this->_content[0])) {
                                        //ok looks like this object has only
                                        //1 data for content and its a string.          
                                        if ( !strstr($this->_content[0], "\n") ) {
                                                $this->newline_after_opentag = FALSE;
                                        }
                                }
                        }
                }
    }


        /****************************************/
        /* Some helper methods for rendering    */
        /* the output xml tree.                                 */
        /****************************************/

        /**
         * this function is responsible for
         * rendering the open tag.
         *
         * @param int - the indent level
         * @param boolean - do we add the finish / if we have no 
         *                  close tag and no content?
         */
        function _render_open_tag( $indent_level, $finish_slash=TRUE ) {

                //get the indent level
                $indent = $this->_render_indent( $indent_level );

                //build the tag
                $tag = $this->_tag;
                if ($this->_always_lower_case) {
                        $tag = strtolower($tag);
                } else if ($this->_always_upper_case) {
                        $tag = strtoupper($tag);
                }
                $xml = $indent . $this->_tag_prefix . $tag;
                
                foreach( $this->_attributes as $name => $value) {
                        $xml .= $this->_build_attribute_string($name, $value);
                }

                if ( !$this->_close_tag_required && !$this->_no_finish_slash_xhtml
                         && $finish_slash ) {
                        $xml .= " /".$this->_tag_postfix;
                } else {
                        $xml .= $this->_tag_postfix;
                }
                
                if ($this->newline_after_opentag) {
                        $xml .= "\n";
                }

                return $xml;
        }


        /**
         * this function is reponsible for 
         * rendering the pcdata, or content
         * of the tag (if any)
         *
         * @param int - the indent level
         */
        function _render_content( $indent_level, $output_debug=0 ) {            
                
                //walk through the content
                $xml = '';              
                foreach ($this->_content as $item) {
                        if (method_exists($item, "render")) {
                                if ($this->_collapse_flag && method_exists($item, "set_collapse")) {
                                        $item->set_collapse(TRUE, FALSE);
                                }
                                if ($indent_level == INDENT_LEFT_JUSTIFY) {
                                        $indent = INDENT_LEFT_JUSTIFY;                      
                                } else {
                                        $indent = $indent_level + 1;
                                }
                                $xml .= $item->render($indent, $output_debug);
                        } else {
                                if ($this->_collapse_flag) {
                                        $xml .= $item;
                                } else {
                                        if ($indent_level == INDENT_LEFT_JUSTIFY) {
                                                $indent = INDENT_LEFT_JUSTIFY;
                                        } else {
                                                $indent = $indent_level + 1;
                                        }
                                        $indent = $this->_render_indent($indent + 1);
                                        if ($this->newline_after_opentag) {                        
                                                $item = str_replace("\n", "\n" . $indent, $item);
                                                $xml .= $indent . $item . "\n";
                                        } else {
                                                $item = str_replace("\n", "\n" . $indent, $item);                   
                                                $xml .= $item;
                                        }
                                }                               
                        }
                }
                if ($this->_cdata_content_wrap) {
                        if ($this->_collapse_flag) {
                                $xml = "<![CDATA[ ".$xml." ]]>";
                        } else {
                                $indent = $this->_render_indent($indent+1);
                                $indent1 = $this->_render_indent($indent+2);
                                $indent2 = $this->_render_indent($indent+3);
                                $xml = "\n".$indent1."<![CDATA[\n".$xml."\n".$indent1."]]>\n".$indent;
                        }
                        
                }
                return $xml;
        }


        /**
         * this function is reposnsible for
         * rendering the closing tag (if any)
         *
         * @param int - the indent level
         */
        function _render_close_tag( $indent_level ) {
                if (!$this->_close_tag_required) {
                        return '';
                }

                $indent = "";
                if ($this->indent_flag && $this->newline_after_opentag) {
                        $indent = $this->_render_indent($indent_level);
                }               
                $str = $indent ."</".$this->_tag.">";
                
                if ($this->newline_after_closetag) {
                        $str .= "\n";
                }
                
                return $str;
        }

    /**
     * this builds an attribute for an XML tag.
     * XML attributes MUST have a name AND a 
         * value.
     *
     * @param   string - $name attribute name
     * @param   mixed - $value attribute value
     * @return  the tag attribute name=value pair.
     *          to be added to the tag.
     */
    function _build_attribute_string($name, $value) {
                if ( ((int)$name - 0) === $name) {
                        $returnval = " ".$value;
                } else if ( $value === NULL ) {
                        $returnval = " ".$name;
                } else {
                        $returnval= " ".$name."=\"".$value."\"";
                }
        return $returnval;
    }
}
?>
1	jonen	1.1	<?php
2
3			/**
4			* Holds the XMLTagClass
5			*
6			* $Id: XMLTagClass.inc,v 1.24 2002/11/16 02:26:22 hemna Exp $
7			*
8			* @author Walter A. Boring IV <waboring@buildabetterweb.com>
9			* @package phpHtmlLib
10			*
11			* @copyright LGPL - See LICENCE
12			*
13			*/
14
15			/**
16			* make sure we include the parent class
17			*/
18			require_once( $phphtmllib."/ContainerClass.inc" );
19
20
21			/**
22			*
23			* This class is used for building and rendering
24			* an XML tag.
25			*
26			* This class is the base class for the
27			* HTMLTagClass.
28			*
29			* This is part of the phphtmllib libraries
30			* released under the LGPL license.
31			*
32			* @author Walter A. Boring IV <waboring@buildabetterweb.com>
33			* @package phpHtmlLib
34			*/
35			class XMLTagClass extends Container {
36
37
38			/**
39			* Tag definition for class.
40			* subclass defines this value.
41			* ie var $tag = "<TABLE>";
42			* @var string
43			* @access private
44			*/
45			var $_tag = "";
46
47			/**
48			* Tag attributes as an array
49			* of name value pairs.
50			* ie $attributes["cellspacing"]=2;
51			* @var array
52			* @access private
53			*/
54			var $_attributes = array();
55
56			/**
57			* flag to render close tag or not.
58			* set to FALSE if no close tag is needed
59			* ie <img src=hotchick.png>
60			* @var boolean
61			* @access private
62			*/
63			var $_close_tag_required = TRUE;
64
65			/**
66			* Flag to render content or not.
67			* set to FALSE to not render content.
68			* ie <img src=hotchick.png>
69			* @var boolean
70			* @access private
71			*/
72			var $_content_required = TRUE;
73
74			/**
75			* Flag to place a newline after open tag.
76			* some tags are nice to have a \n after
77			* to make reading of html easier.
78			* ie <table>
79			* @var boolean
80			* @access public
81			*/
82			var $newline_after_opentag = TRUE;
83
84			/**
85			* Flag to place a newline after close tag.
86			* usefull for maintaining nice output inside
87			* a table
88			* @var boolean
89			* @access public
90			*/
91			var $newline_after_closetag = TRUE;
92
93			/**
94			* Flag to tell the renderer to NEVER
95			* to render the tag name in lower case
96			* no matter what
97			* @var boolean
98			* @access private
99			*/
100			var $_always_upper_case = FALSE;
101
102			/**
103			* Flag to tell the renderer to NEVER
104			* to render the tag name in upper case
105			* no matter what
106			* @var boolean
107			* @access private
108			*/
109			var $_always_lower_case = FALSE;
110
111			/**
112			* Automatically wrap ALL content
113			* inside the <![CDATA[ CONTENT ]]>
114			* tag
115			*
116			* @var boolean
117			*/
118			var $_cdata_content_wrap = FALSE;
119
120
121			/**
122			* holds the tag prefix
123			*
124			*/
125			var $_tag_prefix = "<";
126
127			/**
128			* holds the tag postfix
129			*
130			*/
131			var $_tag_postfix = ">";
132
133
134
135
136			/**
137			* The constructor
138			*
139			* @param string - the tag name
140			* @param array - the attributes array
141			* can be in name => value
142			* or just value
143			* @param mixed - n items of content to
144			* add
145			*
146			*/
147			function XMLTagClass($name, $attributes=array() ) {
148			$this->set_tag_name( $name );
149			$this->set_tag_attributes( $attributes );
150
151			$num_args = func_num_args();
152			for ($i=2;$i<$num_args;$i++) {
153			$this->add(func_get_arg($i));
154			}
155			}
156
157
158			/**
159			* This function is responsible
160			* for rendering the tag and
161			* its contents
162			*
163			* @param int - the current indentation
164			* level for the tag
165			*/
166			function render( $indent_level=0 ) {
167
168			//try and guess the indentation flags
169			//based on the data
170			$this->_prepare_flags();
171
172			//build the open tag and its
173			//attributes
174			$xml = $this->_render_open_tag( $indent_level );
175
176			//build the content or PCDATA
177			$xml .= $this->_render_content( $indent_level );
178
179			//build the close tag
180			//if required.
181			$xml .= $this->_render_close_tag( $indent_level );
182
183			return $xml;
184			}
185
186
187			/****************************************/
188			/* Some helper routines for building */
189			/* pieces of the xml tag, its */
190			/* attributes and PCDATA */
191			/****************************************/
192
193
194			/**
195			* This method sets the name of the tag
196			*
197			* @param string - the tag name
198			*/
199			function set_tag_name( $name ) {
200			$this->_tag = $name;
201			}
202
203			/**
204			* This method gets the name of the tag
205			*
206			* @return string - the tag name
207			*/
208			function get_tag_name() {
209			return $this->_tag;
210			}
211
212			/**
213			* This returns the tag declared for this class.
214			* This should be used in favor of
215			* accessing the $this->_tag directly.
216			*
217			* @return string - the _tag var for this class.
218			*/
219			function get_tag() {
220			//for compatibility only
221			return $this->get_tag_name();
222			}
223
224			/**
225			* add a single attribute (name="value")
226			* @param string $name attribute name
227			* @param mixed $value the value.
228			* @access public
229			*/
230			function set_tag_attribute( $name, $value=NULL ) {
231			$this->_attributes[$name] = $value;
232			}
233
234			/**
235			* add multiple attributes (name="value")
236			* @param array $attributes Associative array of name="value" pairs of
237			* tag atributes.
238			* ie array("border"=>"0", "class"=>"hover");
239			* @access public
240			*/
241			function set_tag_attributes( $attributes=array() ) {
242			$this->_attributes = array_merge($this->_attributes, $attributes);
243			}
244
245			/**
246			* clear all attributes and start with new attributes
247			* @param array $attributes Associative array of name="value" pairs of
248			* tag atributes.
249			* ie array("border"=>"0", "class"=>"hover");
250			* @access public
251			*/
252			function reset_attributes( $attributes=array() ) {
253			$this->_attributes = array();
254			$this->set_tag_attributes( $attributes );
255			}
256
257			/**
258			* get the nth element from content array
259			* @param int $cell the cell to get
260			* @return mixed
261			*/
262			function _get_element( $cell ) {
263			return $this->_content[$cell];
264			}
265
266
267
268			//****************************************************************
269			// Misc functions
270			//****************************************************************
271
272			/**
273			* set the newline_after_opentag flag
274			* @param boolean $flag TRUE or FALSE
275			*/
276			function set_newline_after_opentag( $flag ) {
277			$this->newline_after_opentag = $flag;
278			}
279
280			/**
281			* set the newline_after_content flag
282			* @param boolean $flag TRUE or FALSE
283			*/
284			function set_newline_after_closetag( $flag ) {
285			$this->newline_after_closetag = $flag;
286			}
287
288			/**
289			* This function turns on the collapse flag
290			*
291			* @param boolean - the collapse flag
292			* @param boolean - the indent flag
293			* DEFAULT: TRUE;
294			*/
295			function set_collapse($collapse=TRUE, $indent=TRUE) {
296			$this->_collapse_flag = $collapse;
297
298			$this->set_newline_after_opentag(FALSE);
299			$this->set_indent_flag($indent);
300			if ($indent) {
301			$this->set_newline_after_closetag(TRUE);
302			} else {
303			$this->set_newline_after_closetag(FALSE);
304			}
305			}
306
307			/**
308			* This function checks to see if
309			* there is only 1 content data, and
310			* its not an object, then it auto
311			* sets some of the indentation flags
312			*
313			*/
314			function _prepare_flags() {
315			if ($this->_content_required) {
316			if ($this->count_content() == 1 \|\| $this->count_content() == 0) {
317			if (!is_object($this->_content[0])) {
318			//ok looks like this object has only
319			//1 data for content and its a string.
320			if ( !strstr($this->_content[0], "\n") ) {
321			$this->newline_after_opentag = FALSE;
322			}
323			}
324			}
325			}
326			}
327
328
329			/****************************************/
330			/* Some helper methods for rendering */
331			/* the output xml tree. */
332			/****************************************/
333
334			/**
335			* this function is responsible for
336			* rendering the open tag.
337			*
338			* @param int - the indent level
339			* @param boolean - do we add the finish / if we have no
340			* close tag and no content?
341			*/
342			function _render_open_tag( $indent_level, $finish_slash=TRUE ) {
343
344			//get the indent level
345			$indent = $this->_render_indent( $indent_level );
346
347			//build the tag
348			$tag = $this->_tag;
349			if ($this->_always_lower_case) {
350			$tag = strtolower($tag);
351			} else if ($this->_always_upper_case) {
352			$tag = strtoupper($tag);
353			}
354			$xml = $indent . $this->_tag_prefix . $tag;
355
356			foreach( $this->_attributes as $name => $value) {
357			$xml .= $this->_build_attribute_string($name, $value);
358			}
359
360			if ( !$this->_close_tag_required && !$this->_no_finish_slash_xhtml
361			&& $finish_slash ) {
362			$xml .= " /".$this->_tag_postfix;
363			} else {
364			$xml .= $this->_tag_postfix;
365			}
366
367			if ($this->newline_after_opentag) {
368			$xml .= "\n";
369			}
370
371			return $xml;
372			}
373
374
375			/**
376			* this function is reponsible for
377			* rendering the pcdata, or content
378			* of the tag (if any)
379			*
380			* @param int - the indent level
381			*/
382			function _render_content( $indent_level, $output_debug=0 ) {
383
384			//walk through the content
385			$xml = '';
386			foreach ($this->_content as $item) {
387			if (method_exists($item, "render")) {
388			if ($this->_collapse_flag && method_exists($item, "set_collapse")) {
389			$item->set_collapse(TRUE, FALSE);
390			}
391			if ($indent_level == INDENT_LEFT_JUSTIFY) {
392			$indent = INDENT_LEFT_JUSTIFY;
393			} else {
394			$indent = $indent_level + 1;
395			}
396			$xml .= $item->render($indent, $output_debug);
397			} else {
398			if ($this->_collapse_flag) {
399			$xml .= $item;
400			} else {
401			if ($indent_level == INDENT_LEFT_JUSTIFY) {
402			$indent = INDENT_LEFT_JUSTIFY;
403			} else {
404			$indent = $indent_level + 1;
405			}
406			$indent = $this->_render_indent($indent + 1);
407			if ($this->newline_after_opentag) {
408			$item = str_replace("\n", "\n" . $indent, $item);
409			$xml .= $indent . $item . "\n";
410			} else {
411			$item = str_replace("\n", "\n" . $indent, $item);
412			$xml .= $item;
413			}
414			}
415			}
416			}
417			if ($this->_cdata_content_wrap) {
418			if ($this->_collapse_flag) {
419			$xml = "<![CDATA[ ".$xml." ]]>";
420			} else {
421			$indent = $this->_render_indent($indent+1);
422			$indent1 = $this->_render_indent($indent+2);
423			$indent2 = $this->_render_indent($indent+3);
424			$xml = "\n".$indent1."<![CDATA[\n".$xml."\n".$indent1."]]>\n".$indent;
425			}
426
427			}
428			return $xml;
429			}
430
431
432			/**
433			* this function is reposnsible for
434			* rendering the closing tag (if any)
435			*
436			* @param int - the indent level
437			*/
438			function _render_close_tag( $indent_level ) {
439			if (!$this->_close_tag_required) {
440			return '';
441			}
442
443			$indent = "";
444			if ($this->indent_flag && $this->newline_after_opentag) {
445			$indent = $this->_render_indent($indent_level);
446			}
447			$str = $indent ."</".$this->_tag.">";
448
449			if ($this->newline_after_closetag) {
450			$str .= "\n";
451			}
452
453			return $str;
454			}
455
456			/**
457			* this builds an attribute for an XML tag.
458			* XML attributes MUST have a name AND a
459			* value.
460			*
461			* @param string - $name attribute name
462			* @param mixed - $value attribute value
463			* @return the tag attribute name=value pair.
464			* to be added to the tag.
465			*/
466			function _build_attribute_string($name, $value) {
467			if ( ((int)$name - 0) === $name) {
468			$returnval = " ".$value;
469			} else if ( $value === NULL ) {
470			$returnval = " ".$name;
471			} else {
472			$returnval= " ".$name."=\"".$value."\"";
473			}
474			return $returnval;
475			}
476			}
477			?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26