You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

559 lines
24 KiB

<?php
/**
* @link http://www.yiiframework.com/
* @copyright Copyright (c) 2008 Yii Software LLC
* @license http://www.yiiframework.com/license/
*/
namespace yii\widgets;
use Yii;
use yii\base\Component;
12 years ago
use yii\db\ActiveRecord;
use yii\helpers\Html;
use yii\base\Model;
use yii\web\JsExpression;
/**
* @author Qiang Xue <qiang.xue@gmail.com>
* @since 2.0
*/
class ActiveField extends Component
{
/**
* @var ActiveForm the form that this field is associated with.
*/
public $form;
/**
* @var Model the data model that this field is associated with
*/
public $model;
/**
* @var string the model attribute that this field is associated with
*/
public $attribute;
/**
12 years ago
* @var string the tag name for the field container.
*/
public $tag = 'div';
/**
* @var array the HTML attributes (name-value pairs) for the field container tag.
* The values will be HTML-encoded using [[Html::encode()]].
* If a value is null, the corresponding attribute will not be rendered.
*/
12 years ago
public $options = array(
'class' => 'form-group',
12 years ago
);
/**
* @var string the template that is used to arrange the label, the input and the error message.
* The following tokens will be replaced when [[render()]] is called: `{label}`, `{input}` and `{error}`.
12 years ago
*/
public $template = "{label}\n{input}\n{error}";
12 years ago
/**
* @var array the default options for the input tags. The parameter passed to individual input methods
* (e.g. [[textInput()]]) will be merged with this property when rendering the input tag.
*/
public $inputOptions = array('class' => 'form-control');
/**
* @var array the default options for the error tags. The parameter passed to [[error()]] will be
* merged with this property when rendering the error tag.
12 years ago
*/
public $errorOptions = array('tag' => 'p', 'class' => 'help-block');
12 years ago
/**
* @var array the default options for the label tags. The parameter passed to [[label()]] will be
* merged with this property when rendering the label tag.
12 years ago
*/
public $labelOptions = array('class' => 'control-label');
12 years ago
/**
* @var boolean whether to enable client-side data validation.
* If not set, it will take the value of [[ActiveForm::enableClientValidation]].
*/
public $enableClientValidation;
/**
* @var boolean whether to enable AJAX-based data validation.
* If not set, it will take the value of [[ActiveForm::enableAjaxValidation]].
*/
public $enableAjaxValidation;
/**
* @var boolean whether to perform validation when the input field loses focus and its value is found changed.
* If not set, it will take the value of [[ActiveForm::validateOnChange]].
*/
public $validateOnChange;
/**
* @var boolean whether to perform validation while the user is typing in the input field.
* If not set, it will take the value of [[ActiveForm::validateOnType]].
* @see validationDelay
*/
public $validateOnType;
/**
12 years ago
* @var integer number of milliseconds that the validation should be delayed when the input field
* is changed or the user types in the field.
12 years ago
* If not set, it will take the value of [[ActiveForm::validationDelay]].
*/
public $validationDelay;
/**
* @var array the jQuery selectors for selecting the container, input and error tags.
* The array keys should be "container", "input", and/or "error", and the array values
* are the corresponding selectors. For example, `array('input' => '#my-input')`.
*
* The container selector is used under the context of the form, while the input and the error
* selectors are used under the context of the container.
12 years ago
*
* You normally do not need to set this property as the default selectors should work well for most cases.
*/
public $selectors;
/**
* Renders the opening tag of the field container.
* @return string the rendering result.
*/
public function begin()
{
12 years ago
$options = $this->getClientOptions();
if (!empty($options)) {
12 years ago
$this->form->attributes[$this->attribute] = $options;
12 years ago
}
12 years ago
$inputID = Html::getInputId($this->model, $this->attribute);
$attribute = Html::getAttributeName($this->attribute);
12 years ago
$options = $this->options;
12 years ago
$class = isset($options['class']) ? array($options['class']) : array();
12 years ago
$class[] = "field-$inputID";
if ($this->model->isAttributeRequired($attribute)) {
$class[] = $this->form->requiredCssClass;
12 years ago
}
12 years ago
if ($this->model->hasErrors($attribute)) {
$class[] = $this->form->errorCssClass;
12 years ago
}
12 years ago
$options['class'] = implode(' ', $class);
12 years ago
12 years ago
return Html::beginTag($this->tag, $options);
}
/**
* Renders the closing tag of the field container.
* @return string the rendering result.
*/
public function end()
{
12 years ago
return Html::endTag($this->tag);
}
/**
* Returns the JS options for the field.
* @return array the JS options
*/
12 years ago
protected function getClientOptions()
{
$enableClientValidation = $this->enableClientValidation || $this->enableClientValidation === null && $this->form->enableClientValidation;
if ($enableClientValidation) {
12 years ago
$attribute = Html::getAttributeName($this->attribute);
$validators = array();
foreach ($this->model->getActiveValidators($attribute) as $validator) {
/** @var \yii\validators\Validator $validator */
$js = $validator->clientValidateAttribute($this->model, $attribute, $this->form->getView());
12 years ago
if ($validator->enableClientValidation && $js != '') {
$validators[] = $js;
}
}
if (!empty($validators)) {
12 years ago
$options['validate'] = new JsExpression("function(attribute, value, messages) {" . implode('', $validators) . '}');
12 years ago
}
}
$enableAjaxValidation = $this->enableAjaxValidation || $this->enableAjaxValidation === null && $this->form->enableAjaxValidation;
if ($enableAjaxValidation) {
12 years ago
$options['enableAjaxValidation'] = 1;
}
if ($enableClientValidation && !empty($options['validate']) || $enableAjaxValidation) {
12 years ago
$inputID = Html::getInputId($this->model, $this->attribute);
$options['name'] = $inputID;
foreach (array('validateOnChange', 'validateOnType', 'validationDelay') as $name) {
12 years ago
$options[$name] = $this->$name === null ? $this->form->$name : $this->$name;
}
$options['container'] = isset($this->selectors['container']) ? $this->selectors['container'] : ".field-$inputID";
$options['input'] = isset($this->selectors['input']) ? $this->selectors['input'] : "#$inputID";
if (isset($this->errorOptions['class'])) {
$options['error'] = '.' . implode('.', preg_split('/\s+/', $this->errorOptions['class'], -1, PREG_SPLIT_NO_EMPTY));
} else {
$options['error'] = isset($this->errorOptions['tag']) ? $this->errorOptions['tag'] : 'span';
}
return $options;
} else {
return array();
}
}
12 years ago
/**
* Generates a label tag for [[attribute]].
* The label text is the label associated with the attribute, obtained via [[Model::getAttributeLabel()]].
* @param array $options the tag options in terms of name-value pairs. It will be merged with [[labelOptions]].
12 years ago
* The options will be rendered as the attributes of the resulting tag. The values will be HTML-encoded
* using [[encode()]]. If a value is null, the corresponding attribute will not be rendered.
*
* The following options are specially handled:
*
* - label: this specifies the label to be displayed. Note that this will NOT be [[encoded()]].
* If this is not set, [[Model::getAttributeLabel()]] will be called to get the label for display
* (after encoding).
*
* @return string the generated label tag
*/
public function label($options = array())
12 years ago
{
$options = array_merge($this->labelOptions, $options);
12 years ago
return Html::activeLabel($this->model, $this->attribute, $options);
}
12 years ago
/**
* Generates a tag that contains the first validation error of [[attribute]].
12 years ago
* Note that even if there is no validation error, this method will still return an empty error tag.
* @param array $options the tag options in terms of name-value pairs. It will be merged with [[errorOptions]].
12 years ago
* The options will be rendered as the attributes of the resulting tag. The values will be HTML-encoded
* using [[Html::encode()]]. If a value is null, the corresponding attribute will not be rendered.
12 years ago
*
* The following options are specially handled:
*
* - tag: this specifies the tag name. If not set, "p" will be used.
12 years ago
*
* @return string the generated label tag
*/
public function error($options = array())
{
$options = array_merge($this->errorOptions, $options);
return Html::error($this->model, $this->attribute, $options);
}
12 years ago
/**
* Renders the field with the given input HTML.
* This method will generate the label and error tags, and return them together with the given
* input HTML according to [[template]].
* @param string $input the input HTML
* @return string the rendering result
*/
public function render($input)
{
12 years ago
return $this->begin() . "\n" . strtr($this->template, array(
12 years ago
'{input}' => $input,
'{label}' => $this->label(),
'{error}' => $this->error(),
12 years ago
)) . "\n" . $this->end();
}
/**
* Renders a field containing an input field.
* @param string $type the input type (e.g. 'text', 'password')
* @param array $options the tag options in terms of name-value pairs. These will be rendered as
* the attributes of the resulting tag. The values will be HTML-encoded using [[encode()]].
* @return string the generated input tag
*/
public function input($type, $options = array())
{
$options = array_merge($this->inputOptions, $options);
12 years ago
return $this->render(Html::activeInput($type, $this->model, $this->attribute, $options));
}
/**
* Renders a field containing a text input.
* This method will generate the "name" and "value" tag attributes automatically for the model attribute
* unless they are explicitly specified in `$options`.
* @param array $options the tag options in terms of name-value pairs. These will be rendered as
* the attributes of the resulting tag. The values will be HTML-encoded using [[encode()]].
* @return string the rendering result
*/
public function textInput($options = array())
{
$options = array_merge($this->inputOptions, $options);
12 years ago
return $this->render(Html::activeTextInput($this->model, $this->attribute, $options));
}
/**
* Renders a field containing a password input.
* This method will generate the "name" and "value" tag attributes automatically for the model attribute
* unless they are explicitly specified in `$options`.
* @param array $options the tag options in terms of name-value pairs. These will be rendered as
* the attributes of the resulting tag. The values will be HTML-encoded using [[encode()]].
* @return string the rendering result
*/
public function passwordInput($options = array())
{
$options = array_merge($this->inputOptions, $options);
12 years ago
return $this->render(Html::activePasswordInput($this->model, $this->attribute, $options));
}
/**
* Renders a field containing a file input.
* This method will generate the "name" and "value" tag attributes automatically for the model attribute
* unless they are explicitly specified in `$options`.
* @param array $options the tag options in terms of name-value pairs. These will be rendered as
* the attributes of the resulting tag. The values will be HTML-encoded using [[encode()]].
* @return string the rendering result
*/
public function fileInput($options = array())
{
$options = array_merge($this->inputOptions, $options);
12 years ago
return $this->render(Html::activeFileInput($this->model, $this->attribute, $options));
}
/**
* Renders a field containing a text area.
* The model attribute value will be used as the content in the textarea.
* @param array $options the tag options in terms of name-value pairs. These will be rendered as
* the attributes of the resulting tag. The values will be HTML-encoded using [[encode()]].
* @return string the rendering result
*/
public function textarea($options = array())
{
$options = array_merge($this->inputOptions, $options);
12 years ago
return $this->render(Html::activeTextarea($this->model, $this->attribute, $options));
}
/**
* Renders a field containing a radio button.
* This method will generate the "name" tag attribute automatically unless it is explicitly specified in `$options`.
* This method will generate the "checked" tag attribute according to the model attribute value.
* @param array $options the tag options in terms of name-value pairs. The following options are specially handled:
*
* - uncheck: string, the value associated with the uncheck state of the radio button. If not set,
* it will take the default value '0'. This method will render a hidden input so that if the radio button
* is not checked and is submitted, the value of this attribute will still be submitted to the server
* via the hidden input.
* - label: string, a label displayed next to the radio button. It will NOT be HTML-encoded. Therefore you can pass
* in HTML code such as an image tag. If this is is coming from end users, you should [[encode()]] it to prevent XSS attacks.
* When this option is specified, the radio button will be enclosed by a label tag.
* - labelOptions: array, the HTML attributes for the label tag. This is only used when the "label" option is specified.
*
* The rest of the options will be rendered as the attributes of the resulting tag. The values will
* be HTML-encoded using [[encode()]]. If a value is null, the corresponding attribute will not be rendered.
* @param boolean $enclosedByLabel whether to enclose the radio within the label.
* If true, the method will still use [[template]] to layout the checkbox and the error message
* except that the radio is enclosed by the label tag.
* @return string the rendering result
*/
public function radio($options = array(), $enclosedByLabel = true)
12 years ago
{
$options = array_merge($this->inputOptions, $options);
if ($enclosedByLabel) {
if (!isset($options['label'])) {
$options['label'] = Html::encode($this->model->getAttributeLabel($this->attribute));
}
$checkbox = Html::activeRadio($this->model, $this->attribute, $options);
return $this->begin() . strtr($this->template, array(
'{input}' => $checkbox,
'{label}' => '',
'{error}' => $this->error(),
)) . "\n" . $this->end();
} else {
return $this->render(Html::activeRadio($this->model, $this->attribute, $options));
}
}
/**
* Renders a field containing a checkbox.
* This method will generate the "name" tag attribute automatically unless it is explicitly specified in `$options`.
* This method will generate the "checked" tag attribute according to the model attribute value.
* @param array $options the tag options in terms of name-value pairs. The following options are specially handled:
*
* - uncheck: string, the value associated with the uncheck state of the radio button. If not set,
* it will take the default value '0'. This method will render a hidden input so that if the radio button
* is not checked and is submitted, the value of this attribute will still be submitted to the server
* via the hidden input.
* - label: string, a label displayed next to the checkbox. It will NOT be HTML-encoded. Therefore you can pass
* in HTML code such as an image tag. If this is is coming from end users, you should [[encode()]] it to prevent XSS attacks.
* When this option is specified, the checkbox will be enclosed by a label tag.
* - labelOptions: array, the HTML attributes for the label tag. This is only used when the "label" option is specified.
*
* The rest of the options will be rendered as the attributes of the resulting tag. The values will
* be HTML-encoded using [[encode()]]. If a value is null, the corresponding attribute will not be rendered.
* @param boolean $enclosedByLabel whether to enclose the checkbox within the label.
* If true, the method will still use [[template]] to layout the checkbox and the error message
* except that the checkbox is enclosed by the label tag.
* @return string the rendering result
*/
public function checkbox($options = array(), $enclosedByLabel = true)
{
if ($enclosedByLabel) {
if (!isset($options['label'])) {
$options['label'] = Html::encode($this->model->getAttributeLabel($this->attribute));
}
$checkbox = Html::activeCheckbox($this->model, $this->attribute, $options);
return $this->begin() . strtr($this->template, array(
'{input}' => $checkbox,
'{label}' => '',
'{error}' => $this->error(),
)) . "\n" . $this->end();
} else {
return $this->render(Html::activeCheckbox($this->model, $this->attribute, $options));
}
}
/**
* Renders a field containing a drop-down list.
* The selection of the drop-down list is taken from the value of the model attribute.
* @param array $items the option data items. The array keys are option values, and the array values
* are the corresponding option labels. The array can also be nested (i.e. some array values are arrays too).
* For each sub-array, an option group will be generated whose label is the key associated with the sub-array.
* If you have a list of data models, you may convert them into the format described above using
* [[\yii\helpers\ArrayHelper::map()]].
*
* Note, the values and labels will be automatically HTML-encoded by this method, and the blank spaces in
* the labels will also be HTML-encoded.
* @param array $options the tag options in terms of name-value pairs. The following options are specially handled:
*
* - prompt: string, a prompt text to be displayed as the first option;
* - options: array, the attributes for the select option tags. The array keys must be valid option values,
* and the array values are the extra attributes for the corresponding option tags. For example,
*
* ~~~
* array(
* 'value1' => array('disabled' => true),
* 'value2' => array('label' => 'value 2'),
* );
* ~~~
*
* - groups: array, the attributes for the optgroup tags. The structure of this is similar to that of 'options',
* except that the array keys represent the optgroup labels specified in $items.
*
* The rest of the options will be rendered as the attributes of the resulting tag. The values will
* be HTML-encoded using [[encode()]]. If a value is null, the corresponding attribute will not be rendered.
*
* @return string the rendering result
*/
12 years ago
public function dropDownList($items, $options = array())
{
$options = array_merge($this->inputOptions, $options);
12 years ago
return $this->render(Html::activeDropDownList($this->model, $this->attribute, $items, $options));
}
/**
* Renders a field containing a list box.
* The selection of the list box is taken from the value of the model attribute.
* @param array $items the option data items. The array keys are option values, and the array values
* are the corresponding option labels. The array can also be nested (i.e. some array values are arrays too).
* For each sub-array, an option group will be generated whose label is the key associated with the sub-array.
* If you have a list of data models, you may convert them into the format described above using
* [[\yii\helpers\ArrayHelper::map()]].
*
* Note, the values and labels will be automatically HTML-encoded by this method, and the blank spaces in
* the labels will also be HTML-encoded.
* @param array $options the tag options in terms of name-value pairs. The following options are specially handled:
*
* - prompt: string, a prompt text to be displayed as the first option;
* - options: array, the attributes for the select option tags. The array keys must be valid option values,
* and the array values are the extra attributes for the corresponding option tags. For example,
*
* ~~~
* array(
* 'value1' => array('disabled' => true),
* 'value2' => array('label' => 'value 2'),
* );
* ~~~
*
* - groups: array, the attributes for the optgroup tags. The structure of this is similar to that of 'options',
* except that the array keys represent the optgroup labels specified in $items.
* - unselect: string, the value that will be submitted when no option is selected.
* When this attribute is set, a hidden field will be generated so that if no option is selected in multiple
* mode, we can still obtain the posted unselect value.
*
* The rest of the options will be rendered as the attributes of the resulting tag. The values will
* be HTML-encoded using [[encode()]]. If a value is null, the corresponding attribute will not be rendered.
*
* @return string the rendering result
*/
public function listBox($items, $options = array())
{
$options = array_merge($this->inputOptions, $options);
12 years ago
return $this->render(Html::activeListBox($this->model, $this->attribute, $items, $options));
}
/**
* Renders a field containing a list of checkboxes.
* A checkbox list allows multiple selection, like [[listBox()]].
* As a result, the corresponding submitted value is an array.
* The selection of the checkbox list is taken from the value of the model attribute.
* @param array $items the data item used to generate the checkboxes.
* The array keys are the labels, while the array values are the corresponding checkbox values.
* Note that the labels will NOT be HTML-encoded, while the values will.
* @param array $options options (name => config) for the checkbox list. The following options are specially handled:
*
* - unselect: string, the value that should be submitted when none of the checkboxes is selected.
* By setting this option, a hidden input will be generated.
* - separator: string, the HTML code that separates items.
* - item: callable, a callback that can be used to customize the generation of the HTML code
* corresponding to a single item in $items. The signature of this callback must be:
*
* ~~~
* function ($index, $label, $name, $checked, $value)
* ~~~
*
* where $index is the zero-based index of the checkbox in the whole list; $label
* is the label for the checkbox; and $name, $value and $checked represent the name,
* value and the checked status of the checkbox input.
* @return string the rendering result
*/
public function checkboxList($items, $options = array())
{
12 years ago
return $this->render(
'<div id="' . Html::getInputId($this->model, $this->attribute) . '">'
. Html::activeCheckboxList($this->model, $this->attribute, $items, $options)
. '</div>'
);
}
/**
* Renders a field containing a list of radio buttons.
* A radio button list is like a checkbox list, except that it only allows single selection.
* The selection of the radio buttons is taken from the value of the model attribute.
* @param array $items the data item used to generate the radio buttons.
* The array keys are the labels, while the array values are the corresponding radio button values.
* Note that the labels will NOT be HTML-encoded, while the values will.
* @param array $options options (name => config) for the radio button list. The following options are specially handled:
*
* - unselect: string, the value that should be submitted when none of the radio buttons is selected.
* By setting this option, a hidden input will be generated.
* - separator: string, the HTML code that separates items.
* - item: callable, a callback that can be used to customize the generation of the HTML code
* corresponding to a single item in $items. The signature of this callback must be:
*
* ~~~
* function ($index, $label, $name, $checked, $value)
* ~~~
*
* where $index is the zero-based index of the radio button in the whole list; $label
* is the label for the radio button; and $name, $value and $checked represent the name,
* value and the checked status of the radio button input.
* @return string the rendering result
*/
public function radioList($items, $options = array())
{
12 years ago
return $this->render(
'<div id="' . Html::getInputId($this->model, $this->attribute) . '">'
. Html::activeRadioList($this->model, $this->attribute, $items, $options)
. '</div>'
);
}
/**
* Renders a field containing an input widget.
*
* Note that the widget must have both `model` and `attribute` properties. They will
* be initialized with [[model]] and [[attribute]] of this field, respectively.
*
* If you want to use a widget that does not have `model` and `attribute` properties,
* please use [[render()]] instead.
*
* @param string $class the widget class name
* @param array $config name-value pairs that will be used to initialize the widget
* @return string the rendering result
*/
public function widget($class, $config = array())
{
/** @var \yii\base\Widget $class */
$config['model'] = $this->model;
$config['attribute'] = $this->attribute;
$config['view'] = $this->form->getView();
return $this->render($class::widget($config));
}
}