Configure the dmca form site on ridley
[chef.git] / cookbooks / dmca / files / default / html / HTML / Common.php
1 <?php
2 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
3
4 /**
5  * Base class for all HTML classes
6  *
7  * PHP versions 4 and 5
8  *
9  * LICENSE: This source file is subject to version 3.01 of the PHP license
10  * that is available through the world-wide-web at the following URI:
11  * http://www.php.net/license/3_01.txt If you did not receive a copy of
12  * the PHP License and are unable to obtain it through the web, please
13  * send a note to license@php.net so we can mail you a copy immediately.
14  * 
15  * @category    HTML
16  * @package     HTML_Common
17  * @author      Adam Daniel <adaniel1@eesus.jnj.com>
18  * @copyright   2001-2009 The PHP Group
19  * @license     http://www.php.net/license/3_01.txt PHP License 3.01
20  * @version     CVS: $Id: Common.php,v 1.15 2009/04/03 15:26:22 avb Exp $
21  * @link        http://pear.php.net/package/HTML_Common/
22  */ 
23
24 /**
25  * Base class for all HTML classes
26  *
27  * @category    HTML
28  * @package     HTML_Common
29  * @author      Adam Daniel <adaniel1@eesus.jnj.com>
30  * @version     Release: 1.2.5
31  * @abstract
32  */
33 class HTML_Common
34 {
35     /**
36      * Associative array of attributes
37      * @var     array
38      * @access  private
39      */
40     var $_attributes = array();
41
42     /**
43      * Tab offset of the tag
44      * @var     int
45      * @access  private
46      */
47     var $_tabOffset = 0;
48
49     /**
50      * Tab string
51      * @var       string
52      * @since     1.7
53      * @access    private
54      */
55     var $_tab = "\11";
56
57     /**
58      * Contains the line end string
59      * @var       string
60      * @since     1.7
61      * @access    private
62      */
63     var $_lineEnd = "\12";
64
65     /**
66      * HTML comment on the object
67      * @var       string
68      * @since     1.5
69      * @access    private
70      */
71     var $_comment = '';
72
73     /**
74      * Class constructor
75      * @param    mixed   $attributes     Associative array of table tag attributes
76      *                                   or HTML attributes name="value" pairs
77      * @param    int     $tabOffset      Indent offset in tabs
78      * @access   public
79      */
80     function HTML_Common($attributes = null, $tabOffset = 0)
81     {
82         $this->setAttributes($attributes);
83         $this->setTabOffset($tabOffset);
84     } // end constructor
85
86     /**
87      * Returns the current API version
88      * @access   public
89      * @returns  double
90      */
91     function apiVersion()
92     {
93         return 1.7;
94     } // end func apiVersion
95
96     /**
97      * Returns the lineEnd
98      *
99      * @since     1.7
100      * @access    private
101      * @return    string
102      */
103     function _getLineEnd()
104     {
105         return $this->_lineEnd;
106     } // end func getLineEnd
107
108     /**
109      * Returns a string containing the unit for indenting HTML
110      *
111      * @since     1.7
112      * @access    private
113      * @return    string
114      */
115     function _getTab()
116     {
117         return $this->_tab;
118     } // end func _getTab
119
120     /**
121      * Returns a string containing the offset for the whole HTML code
122      *
123      * @return    string
124      * @access   private
125      */
126     function _getTabs()
127     {
128         return str_repeat($this->_getTab(), $this->_tabOffset);
129     } // end func _getTabs
130
131     /**
132      * Returns an HTML formatted attribute string
133      * @param    array   $attributes
134      * @return   string
135      * @access   private
136      */
137     function _getAttrString($attributes)
138     {
139         $strAttr = '';
140
141         if (is_array($attributes)) {
142             $charset = HTML_Common::charset();
143             foreach ($attributes as $key => $value) {
144                 $strAttr .= ' ' . $key . '="' . htmlspecialchars($value, ENT_COMPAT, $charset) . '"';
145             }
146         }
147         return $strAttr;
148     } // end func _getAttrString
149
150     /**
151      * Returns a valid atrributes array from either a string or array
152      * @param    mixed   $attributes     Either a typical HTML attribute string or an associative array
153      * @access   private
154      * @return   array
155      */
156     function _parseAttributes($attributes)
157     {
158         if (is_array($attributes)) {
159             $ret = array();
160             foreach ($attributes as $key => $value) {
161                 if (is_int($key)) {
162                     $key = $value = strtolower($value);
163                 } else {
164                     $key = strtolower($key);
165                 }
166                 $ret[$key] = $value;
167             }
168             return $ret;
169
170         } elseif (is_string($attributes)) {
171             $preg = "/(([A-Za-z_:]|[^\\x00-\\x7F])([A-Za-z0-9_:.-]|[^\\x00-\\x7F])*)" .
172                 "([ \\n\\t\\r]+)?(=([ \\n\\t\\r]+)?(\"[^\"]*\"|'[^']*'|[^ \\n\\t\\r]*))?/";
173             if (preg_match_all($preg, $attributes, $regs)) {
174                 for ($counter=0; $counter<count($regs[1]); $counter++) {
175                     $name  = $regs[1][$counter];
176                     $check = $regs[0][$counter];
177                     $value = $regs[7][$counter];
178                     if (trim($name) == trim($check)) {
179                         $arrAttr[strtolower(trim($name))] = strtolower(trim($name));
180                     } else {
181                         if (substr($value, 0, 1) == "\"" || substr($value, 0, 1) == "'") {
182                             $arrAttr[strtolower(trim($name))] = substr($value, 1, -1);
183                         } else {
184                             $arrAttr[strtolower(trim($name))] = trim($value);
185                         }
186                     }
187                 }
188                 return $arrAttr;
189             }
190         }
191     } // end func _parseAttributes
192
193     /**
194      * Returns the array key for the given non-name-value pair attribute
195      *
196      * @param     string    $attr         Attribute
197      * @param     array     $attributes   Array of attribute
198      * @since     1.0
199      * @access    private
200      * @return    bool
201      */
202     function _getAttrKey($attr, $attributes)
203     {
204         if (isset($attributes[strtolower($attr)])) {
205             return true;
206         } else {
207             return null;
208         }
209     } //end func _getAttrKey
210
211     /**
212      * Updates the attributes in $attr1 with the values in $attr2 without changing the other existing attributes
213      * @param    array   $attr1      Original attributes array
214      * @param    array   $attr2      New attributes array
215      * @access   private
216      */
217     function _updateAttrArray(&$attr1, $attr2)
218     {
219         if (!is_array($attr2)) {
220             return false;
221         }
222         foreach ($attr2 as $key => $value) {
223             $attr1[$key] = $value;
224         }
225     } // end func _updateAtrrArray
226
227     /**
228      * Removes the given attribute from the given array
229      *
230      * @param     string    $attr           Attribute name
231      * @param     array     $attributes     Attribute array
232      * @since     1.4
233      * @access    private
234      * @return    void
235      */
236     function _removeAttr($attr, &$attributes)
237     {
238         $attr = strtolower($attr);
239         if (isset($attributes[$attr])) {
240             unset($attributes[$attr]);
241         }
242     } //end func _removeAttr
243
244     /**
245      * Returns the value of the given attribute
246      *
247      * @param     string    $attr   Attribute name
248      * @since     1.5
249      * @access    public
250      * @return    string|null   returns null if an attribute does not exist
251      */
252     function getAttribute($attr)
253     {
254         $attr = strtolower($attr);
255         if (isset($this->_attributes[$attr])) {
256             return $this->_attributes[$attr];
257         }
258         return null;
259     } //end func getAttribute
260
261     /**
262      * Sets the value of the attribute
263      *
264      * @param   string  Attribute name
265      * @param   string  Attribute value (will be set to $name if omitted)
266      * @access  public
267      */
268     function setAttribute($name, $value = null)
269     {
270         $name = strtolower($name);
271         if (is_null($value)) {
272             $value = $name;
273         }
274         $this->_attributes[$name] = $value;
275     } // end func setAttribute
276
277     /**
278      * Sets the HTML attributes
279      * @param    mixed   $attributes     Either a typical HTML attribute string or an associative array
280      * @access   public
281      */
282     function setAttributes($attributes)
283     {
284         $this->_attributes = $this->_parseAttributes($attributes);
285     } // end func setAttributes
286
287     /**
288      * Returns the assoc array (default) or string of attributes
289      *
290      * @param     bool    Whether to return the attributes as string
291      * @since     1.6
292      * @access    public
293      * @return    mixed   attributes
294      */
295     function getAttributes($asString = false)
296     {
297         if ($asString) {
298             return $this->_getAttrString($this->_attributes);
299         } else {
300             return $this->_attributes;
301         }
302     } //end func getAttributes
303
304     /**
305      * Updates the passed attributes without changing the other existing attributes
306      * @param    mixed   $attributes     Either a typical HTML attribute string or an associative array
307      * @access   public
308      */
309     function updateAttributes($attributes)
310     {
311         $this->_updateAttrArray($this->_attributes, $this->_parseAttributes($attributes));
312     } // end func updateAttributes
313
314     /**
315      * Removes an attribute
316      *
317      * @param     string    $attr   Attribute name
318      * @since     1.4
319      * @access    public
320      * @return    void
321      */
322     function removeAttribute($attr)
323     {
324         $this->_removeAttr($attr, $this->_attributes);
325     } //end func removeAttribute
326
327     /**
328      * Sets the line end style to Windows, Mac, Unix or a custom string.
329      *
330      * @param   string  $style  "win", "mac", "unix" or custom string.
331      * @since   1.7
332      * @access  public
333      * @return  void
334      */
335     function setLineEnd($style)
336     {
337         switch ($style) {
338             case 'win':
339                 $this->_lineEnd = "\15\12";
340                 break;
341             case 'unix':
342                 $this->_lineEnd = "\12";
343                 break;
344             case 'mac':
345                 $this->_lineEnd = "\15";
346                 break;
347             default:
348                 $this->_lineEnd = $style;
349         }
350     } // end func setLineEnd
351
352     /**
353      * Sets the tab offset
354      *
355      * @param    int     $offset
356      * @access   public
357      */
358     function setTabOffset($offset)
359     {
360         $this->_tabOffset = $offset;
361     } // end func setTabOffset
362
363     /**
364      * Returns the tabOffset
365      *
366      * @since     1.5
367      * @access    public
368      * @return    int
369      */
370     function getTabOffset()
371     {
372         return $this->_tabOffset;
373     } //end func getTabOffset
374
375     /**
376      * Sets the string used to indent HTML
377      *
378      * @since     1.7
379      * @param     string    $string     String used to indent ("\11", "\t", '  ', etc.).
380      * @access    public
381      * @return    void
382      */
383     function setTab($string)
384     {
385         $this->_tab = $string;
386     } // end func setTab
387
388     /**
389      * Sets the HTML comment to be displayed at the beginning of the HTML string
390      *
391      * @param     string
392      * @since     1.4
393      * @access    public
394      * @return    void
395      */
396     function setComment($comment)
397     {
398         $this->_comment = $comment;
399     } // end func setHtmlComment
400
401     /**
402      * Returns the HTML comment
403      *
404      * @since     1.5
405      * @access    public
406      * @return    string
407      */
408     function getComment()
409     {
410         return $this->_comment;
411     } //end func getComment
412
413     /**
414      * Abstract method.  Must be extended to return the objects HTML
415      *
416      * @access    public
417      * @return    string
418      * @abstract
419      */
420     function toHtml()
421     {
422         return '';
423     } // end func toHtml
424
425     /**
426      * Displays the HTML to the screen
427      *
428      * @access    public
429      */
430     function display()
431     {
432         print $this->toHtml();
433     } // end func display
434
435     /**
436      * Sets the charset to use by htmlspecialchars() function
437      *
438      * Since this parameter is expected to be global, the function is designed
439      * to be called statically:
440      * <code>
441      * HTML_Common::charset('utf-8');
442      * </code>
443      * or
444      * <code>
445      * $charset = HTML_Common::charset();
446      * </code>
447      *
448      * @param   string  New charset to use. Omit if just getting the 
449      *                  current value. Consult the htmlspecialchars() docs 
450      *                  for a list of supported character sets.
451      * @return  string  Current charset
452      * @access  public
453      * @static
454      */
455     function charset($newCharset = null)
456     {
457         static $charset = 'ISO-8859-1';
458
459         if (!is_null($newCharset)) {
460             $charset = $newCharset;
461         }
462         return $charset;
463     } // end func charset
464 } // end class HTML_Common
465 ?>