'
html_eo('img', array(
'src' => '…',
'ref' => false,
'class' => array(),
'alt' => "",
))
⇒ '
'
Generate an XHTML E̲lement O̲pen tag for $name, with attributes
defined by key/value pairs properly inserted. Attribute values
are coerced into strings from integers (by casting) or arrays
(by concatenating the array elements with spaces); if the value
is === false or an empty array (count($attrs[n]) == 0), the
attribute is not output at all, but for empty values it is; see
the img example (admittedly bad, you’d use html_e() for "img").
• string html_e(string $name, optional(empty) array $attrs,
optional(empty) string $content, optional(true) bool $shortform)
html_e('br')
⇒ '
'
html_e('a', array('href' => '/foo.php?a=1&b=2'), 'täxt')
⇒ '
täxt'
html_e('script', array(
'type' => 'text/javascript',
'src' => '/js/foo.js',
), "", false)
⇒ ''
/* needed because does not work */
html_e('tr', array(), html_e('td', array(), 'bla'))
⇒ '
bla |
'
As with html_eo() the first two arguments define the tag to open.
The third argument will be placed between the opening and closing
tags but – in contrast to attribute values – not entity-encoded.
If the third argument is empty, either a self-closing (default)
tag, or, if the fourth argument is false, an open-close sequence,
is emitted.
‣ Autoclose stack functions
$spos = html_ap();
$s = html_ao('p');
if ($foo) {
$s .= html_ao('strong');
}
$s .= html_ao('a', array('href' => '/'));
$s .= somefunc();
$s .= html_ac($spos);
⇒ '
somefuncreturnvalue
'
⇒ '
somefuncreturnvalue
'
• integer html_ap(void)
Return the a̲utoclose stack’s current p̲osition.
• string html_ao(string $name, optional(empty) array $attrs)
Works the same as html_eo() but pushes $name onto the a̲utoclose
element stack when o̲pening it.
• string html_ac(integer $spos)
Return a set of closing elements until the a̲utoc̲lose stack
has reached the position it had when html_ap() returned $spos.
If $spos === false: an empty string is returned, for html_aonce().
If $spos < current stack position, an Exception is raised.
• string html_aonce(ByRef integer $sptr, string $name,
optional(empty) array $attrs)
$spos = false;
foreach ($row in $rows) {
echo html_aonce('table');
echo html_e('tr', array(), html_e('td', array(),
util_html_secure($row['data'])));
}
echo html_ac($spos);
⇒ '' // if $rows is empty
⇒ '
'
If $sptr is not false, do nothing. Otherwise, set it to
the current html_ap() then do html_ao($name, $attrs).
This function can easily be used to open an enclosing element
with mandatory inner elements, such as a table, only once except
if no table row were to be generated.
‣ Autoclose stack copy functions
$spos = html_ap();
echo html_ao('tr', array('bgcolor' => '#FF0000'));
echo html_ao('td');
echo "content 1";
$scopy = html_a_copy($spos);
echo html_ac($spos);
echo html_e('tr', array(), html_e('td', array(), "intermediate"));
echo html_a_apply($scopy);
echo "content 2";
echo html_ac($spos);
echo html_a_apply($scopy);
echo "content 3";
echo html_ac($spos);
⇒
content 1 |
intermediate |
content 2 |
content 3 |
• opaque html_a_copy(integer $spos)
• string html_a_apply(opaque $scopy)
Before autoclosing the stack down to a level $spos, you can
retrieve a copy of the stack in an opaque format, which can
later be used to (re-)open the same elements, with the same
attributes, even in a different nesting state.