Current File : //proc/self/root/home/tjamichg/cursos.tjamich.gob.mx/main/inc/lib/pear/HTML/QuickForm/group.php
<?php
/**
* HTML class for a form element group.
*
* PHP versions 4 and 5
*
* LICENSE: This source file is subject to version 3.01 of the PHP license
* that is available through the world-wide-web at the following URI:
* http://www.php.net/license/3_01.txt If you did not receive a copy of
* the PHP License and are unable to obtain it through the web, please
* send a note to license@php.net so we can mail you a copy immediately.
*
* @category HTML
*
* @author Adam Daniel <adaniel1@eesus.jnj.com>
* @author Bertrand Mansion <bmansion@mamasam.com>
* @author Alexey Borzov <avb@php.net>
* @copyright 2001-2009 The PHP Group
* @license http://www.php.net/license/3_01.txt PHP License 3.01
*
* @version CVS: $Id: group.php,v 1.40 2009/04/04 21:34:03 avb Exp $
*
* @see http://pear.php.net/package/HTML_QuickForm
*/
/**
* HTML class for a form element group.
*
* @category HTML
*
* @author Adam Daniel <adaniel1@eesus.jnj.com>
* @author Bertrand Mansion <bmansion@mamasam.com>
* @author Alexey Borzov <avb@php.net>
*
* @version Release: 3.2.11
*
* @since 1.0
*/
class HTML_QuickForm_group extends HTML_QuickForm_element
{
/**
* Name of the element.
*
* @var string
*
* @since 1.0
*/
private $_name = '';
/**
* Array of grouped elements.
*
* @var array
*
* @since 1.0
*/
private $_elements = [];
/**
* String to separate elements.
*
* @var mixed
*
* @since 2.5
*/
public $_separator = null;
/**
* Required elements in this group.
*
* @var array
*
* @since 2.5
*/
private $_required = [];
/**
* Whether to change elements' names to $groupName[$elementName] or leave them as is.
*
* @var bool
*
* @since 3.0
*/
private $_appendName = true;
/**
* Class constructor.
*
* @param string $elementName (optional)Group name
* @param array $elementLabel (optional)Group label
* @param array $elements (optional)Group elements
* @param mixed $separator (optional)Use a string for one separator,
* use an array to alternate the separators
* @param bool $appendName (optional)whether to change elements' names to
* the form $groupName[$elementName] or leave
* them as is
*
* @since 1.0
*
* @return void
*/
public function __construct(
$elementName = null,
$elementLabel = null,
$elements = null,
$separator = null,
$appendName = true
) {
parent::__construct($elementName, $elementLabel);
$this->_type = 'group';
if (isset($elements) && is_array($elements)) {
$this->setElements($elements);
}
$this->_separator = '';
if (isset($separator)) {
$this->_separator = $separator;
}
if (isset($appendName)) {
$this->_appendName = $appendName;
}
}
/**
* Sets the group name.
*
* @param string $name Group name
*
* @since 1.0
*
* @return void
*/
public function setName($name)
{
$this->_name = $name;
}
/**
* Returns the group name.
*
* @since 1.0
*
* @return string
*/
public function getName()
{
return $this->_name;
}
/**
* Sets values for group's elements.
*
* @param mixed Values for group's elements
*
* @since 1.0
*
* @return void
*/
public function setValue($value)
{
$this->_createElementsIfNotExist();
foreach (array_keys($this->_elements) as $key) {
if (!$this->_appendName) {
$v = $this->_elements[$key]->_findValue($value);
if (null !== $v) {
$this->_elements[$key]->onQuickFormEvent('setGroupValue', $v, $this);
}
} else {
$elementName = $this->_elements[$key]->getName();
$index = strlen($elementName) ? $elementName : $key;
if (is_array($value)) {
if (isset($value[$index])) {
$this->_elements[$key]->onQuickFormEvent('setGroupValue', $value[$index], $this);
}
} elseif (isset($value)) {
$this->_elements[$key]->onQuickFormEvent('setGroupValue', $value, $this);
}
}
}
}
/**
* Returns the value of the group.
*
* @since 1.0
*
* @return mixed
*/
public function getValue()
{
$value = null;
foreach (array_keys($this->_elements) as $key) {
$element = &$this->_elements[$key];
switch ($element->getType()) {
case 'radio':
$v = $element->getChecked() ? $element->getValue() : null;
break;
case 'checkbox':
$v = $element->getChecked() ? true : null;
break;
default:
$v = $element->getValue();
}
if (null !== $v) {
$elementName = $element->getName();
if (is_null($elementName)) {
$value = $v;
} else {
if (!is_array($value)) {
$value = is_null($value) ? [] : [$value];
}
if ('' === $elementName) {
$value[] = $v;
} else {
$value[$elementName] = $v;
}
}
}
}
return $value;
}
/**
* Sets the grouped elements.
*
* @param array $elements Array of elements
*
* @since 1.1
*
* @return void
*/
public function setElements($elements)
{
$this->_elements = array_values($elements);
if ($this->_flagFrozen) {
$this->freeze();
}
}
/**
* Gets the grouped elements.
*
* @since 2.4
*
* @return array
*/
public function &getElements()
{
$this->_createElementsIfNotExist();
return $this->_elements;
}
/**
* Gets the group type based on its elements
* Will return 'mixed' if elements contained in the group
* are of different types.
*
* @return string group elements type
*/
public function getGroupType()
{
$this->_createElementsIfNotExist();
$prevType = '';
foreach (array_keys($this->_elements) as $key) {
$type = $this->_elements[$key]->getType();
if ($type != $prevType && '' != $prevType) {
return 'mixed';
}
$prevType = $type;
}
return $type;
}
/**
* Returns Html for the group.
*
* @since 1.0
*
* @return string
*/
public function toHtml()
{
$renderer = new HTML_QuickForm_Renderer_Default();
$renderer->setElementTemplate('{element}');
$this->accept($renderer);
return $renderer->toHtml();
}
/**
* Returns the element name inside the group such as found in the html form.
*
* @param mixed $index Element name or element index in the group
*
* @since 3.0
*
* @return mixed string with element name, false if not found
*/
public function getElementName($index)
{
$this->_createElementsIfNotExist();
$elementName = false;
if (is_int($index) && isset($this->_elements[$index])) {
$elementName = $this->_elements[$index]->getName();
if (isset($elementName) && '' == $elementName) {
$elementName = $index;
}
if ($this->_appendName) {
if (is_null($elementName)) {
$elementName = $this->getName();
} else {
$elementName = $this->getName().'['.$elementName.']';
}
}
} elseif (is_string($index)) {
foreach (array_keys($this->_elements) as $key) {
$elementName = $this->_elements[$key]->getName();
if ($index == $elementName) {
if ($this->_appendName) {
$elementName = $this->getName().'['.$elementName.']';
}
break;
} elseif ($this->_appendName && $this->getName().'['.$elementName.']' == $index) {
break;
}
}
}
return $elementName;
}
/**
* Returns the value of field without HTML tags.
*
* @since 1.3
*
* @return string
*/
public function getFrozenHtml()
{
$flags = [];
$this->_createElementsIfNotExist();
foreach (array_keys($this->_elements) as $key) {
if (false === ($flags[$key] = $this->_elements[$key]->isFrozen())) {
$this->_elements[$key]->freeze();
}
}
$html = $this->toHtml();
foreach (array_keys($this->_elements) as $key) {
if (!$flags[$key]) {
$this->_elements[$key]->unfreeze();
}
}
return $html;
}
/**
* Called by HTML_QuickForm whenever form event is made on this element.
*
* @param string $event Name of event
* @param mixed $arg event arguments
* @param object &$caller calling object
*
* @since 1.0
*
* @return void
*/
public function onQuickFormEvent($event, $arg, &$caller)
{
switch ($event) {
case 'updateValue':
$this->_createElementsIfNotExist();
foreach (array_keys($this->_elements) as $key) {
if ($this->_appendName) {
$elementName = $this->_elements[$key]->getName();
if (is_null($elementName)) {
$this->_elements[$key]->setName($this->getName());
} elseif ('' === $elementName) {
$this->_elements[$key]->setName($this->getName().'['.$key.']');
} else {
$this->_elements[$key]->setName($this->getName().'['.$elementName.']');
}
}
$this->_elements[$key]->onQuickFormEvent('updateValue', $arg, $caller);
if ($this->_appendName) {
$this->_elements[$key]->setName($elementName);
}
}
break;
default:
parent::onQuickFormEvent($event, $arg, $caller);
}
return true;
}
/**
* Accepts a renderer.
*
* @param HTML_QuickForm_Renderer renderer object
* @param bool Whether a group is required
* @param string An error message associated with a group
*
* @return void
*/
public function accept(&$renderer, $required = false, $error = null)
{
$this->_createElementsIfNotExist();
$renderer->startGroup($this, $required, $error);
$name = $this->getName();
/** @var HTML_QuickForm_element $element */
foreach (array_keys($this->_elements) as $key) {
$element = &$this->_elements[$key];
$element->setLayout($this->getLayout());
if ($this->_appendName) {
$elementName = $element->getName();
if (isset($elementName)) {
$element->setName($name.'['.(strlen($elementName) ? $elementName : $key).']');
} else {
$element->setName($name);
}
}
$required = !$element->isFrozen() && in_array($element->getName(), $this->_required);
$element->accept($renderer, $required);
// restore the element's name
if ($this->_appendName) {
$element->setName($elementName);
}
}
$renderer->finishGroup($this);
}
/**
* As usual, to get the group's value we access its elements and call
* their exportValue() methods.
*/
public function exportValue(&$submitValues, $assoc = false)
{
$value = null;
foreach (array_keys($this->_elements) as $key) {
$elementName = $this->_elements[$key]->getName();
if ($this->_appendName) {
if (is_null($elementName)) {
$this->_elements[$key]->setName($this->getName());
} elseif ('' === $elementName) {
$this->_elements[$key]->setName($this->getName().'['.$key.']');
} else {
$this->_elements[$key]->setName($this->getName().'['.$elementName.']');
}
}
$v = $this->_elements[$key]->exportValue($submitValues, $assoc);
if ($this->_appendName) {
$this->_elements[$key]->setName($elementName);
}
if (null !== $v) {
// Make $value an array, we will use it like one
if (null === $value) {
$value = [];
}
if ($assoc) {
// just like HTML_QuickForm::exportValues()
$value = HTML_QuickForm::arrayMerge($value, $v);
} else {
// just like getValue(), but should work OK every time here
if (is_null($elementName)) {
$value = $v;
} elseif ('' === $elementName) {
$value[] = $v;
} else {
$value[$elementName] = $v;
}
}
}
}
// do not pass the value through _prepareValue, we took care of this already
return $value;
}
/**
* Creates the group's elements.
*
* This should be overriden by child classes that need to create their
* elements. The method will be called automatically when needed, calling
* it from the constructor is discouraged as the constructor is usually
* called _twice_ on element creation, first time with _no_ parameters.
*
* @abstract
*/
public function _createElements()
{
// abstract
}
/**
* A wrapper around _createElements().
*
* This method calls _createElements() if the group's _elements array
* is empty. It also performs some updates, e.g. freezes the created
* elements if the group is already frozen.
*/
public function _createElementsIfNotExist()
{
if (empty($this->_elements)) {
$this->_createElements();
if ($this->_flagFrozen) {
$this->freeze();
}
}
}
public function freeze()
{
parent::freeze();
foreach (array_keys($this->_elements) as $key) {
$this->_elements[$key]->freezeSeeOnlySelected = $this->freezeSeeOnlySelected;
$this->_elements[$key]->freeze();
}
}
public function unfreeze()
{
parent::unfreeze();
foreach (array_keys($this->_elements) as $key) {
$this->_elements[$key]->unfreeze();
}
}
public function setPersistantFreeze($persistant = false)
{
parent::setPersistantFreeze($persistant);
foreach (array_keys($this->_elements) as $key) {
$this->_elements[$key]->setPersistantFreeze($persistant);
}
}
/**
* @param string $layout
*
* @return string
*/
public function getTemplate($layout)
{
$size = $this->calculateSize();
switch ($layout) {
case FormValidator::LAYOUT_INLINE:
return '
<div class="input-group">
<label {label-for} >
<!-- BEGIN required --><span class="form_required">*</span><!-- END required -->
{label}
</label>
</div>
<div class="input-group {error_class}">
{element}
</div>
';
break;
case FormValidator::LAYOUT_HORIZONTAL:
return '
<div class="form-group {error_class}" id="'.$this->getName().'-group">
<label {label-for} class="col-sm-'.$size[0].' control-label {extra_label_class}" >
<!-- BEGIN required --><span class="form_required">*</span><!-- END required -->
{label}
</label>
<div class="col-sm-'.$size[1].'">
{icon}
{element}
<!-- BEGIN label_2 -->
<p class="help-block">{label_2}</p>
<!-- END label_2 -->
<!-- BEGIN error -->
<span class="help-inline help-block">{error}</span>
<!-- END error -->
</div>
<div class="col-sm-'.$size[2].'">
<!-- BEGIN label_3 -->
{label_3}
<!-- END label_3 -->
</div>
</div>';
break;
case FormValidator::LAYOUT_BOX_NO_LABEL:
return '
<div class="input-group">
{icon}
{element}
</div>';
break;
case FormValidator::LAYOUT_BOX:
return '
<div class="input-group">
<label>{label}</label>
{icon}
{element}
</div>';
break;
}
}
}
Mini Shell