Mikescher/www.mikescher.com
1
0
Fork 0
Code Actions Activity

Added new (clean) yii boilerplate

Browse Source
This commit is contained in:
Mike Schwörer
2014-05-13 12:40:42 +02:00
parent 1d6d975a16
commit 99d29b432b
1983 changed files with 653465 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

635
framework/web/form/CForm.php Normal file
View File

@@ -0,0 +1,635 @@
<?php
/**
* CForm class file.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @link http://www.yiiframework.com/
* @copyright 2008-2013 Yii Software LLC
* @license http://www.yiiframework.com/license/
*/
/**
* CForm represents a form object that contains form input specifications.
*
* The main purpose of introducing the abstraction of form objects is to enhance the
* reusability of forms. In particular, we can divide a form in two parts: those
* that specify each individual form inputs, and those that decorate the form inputs.
* A CForm object represents the former part. It relies on the rendering process to
* accomplish form input decoration. Reusability is mainly achieved in the rendering process.
* That is, a rendering process can be reused to render different CForm objects.
*
* A form can be rendered in different ways. One can call the {@link render} method
* to get a quick form rendering without writing any HTML code; one can also override
* {@link render} to render the form in a different layout; and one can use an external
* view template to render each form element explicitly. In these ways, the {@link render}
* method can be applied to all kinds of forms and thus achieves maximum reusability;
* while the external view template keeps maximum flexibility in rendering complex forms.
*
* Form input specifications are organized in terms of a form element hierarchy.
* At the root of the hierarchy, it is the root CForm object. The root form object maintains
* its children in two collections: {@link elements} and {@link buttons}.
* The former contains non-button form elements ({@link CFormStringElement},
* {@link CFormInputElement} and CForm); while the latter mainly contains
* button elements ({@link CFormButtonElement}). When a CForm object is embedded in the
* {@link elements} collection, it is called a sub-form which can have its own {@link elements}
* and {@link buttons} collections and thus form the whole form hierarchy.
*
* Sub-forms are mainly used to handle multiple models. For example, in a user
* registration form, we can have the root form to collect input for the user
* table while a sub-form to collect input for the profile table. Sub-form is also
* a good way to partition a lengthy form into shorter ones, even though all inputs
* may belong to the same model.
*
* Form input specifications are given in terms of a configuration array which is
* used to initialize the property values of a CForm object. The {@link elements} and
* {@link buttons} properties need special attention as they are the main properties
* to be configured. To configure {@link elements}, we should give it an array like
* the following:
* <pre>
* 'elements'=>array(
* 'username'=>array('type'=>'text', 'maxlength'=>80),
* 'password'=>array('type'=>'password', 'maxlength'=>80),
* )
* </pre>
* The above code specifies two input elements: 'username' and 'password'. Note the model
* object must have exactly the same attributes 'username' and 'password'. Each element
* has a type which specifies what kind of input should be used. The rest of the array elements
* (e.g. 'maxlength') in an input specification are rendered as HTML element attributes
* when the input field is rendered. The {@link buttons} property is configured similarly.
*
* If you're going to use AJAX and/or client form validation with the enabled error summary
* you have to set {@link $showErrors} property to true. Please refer to it's documentation
* for more details.
*
* For more details about configuring form elements, please refer to {@link CFormInputElement}
* and {@link CFormButtonElement}.
*
* @property CForm $root The top-level form object.
* @property CActiveForm $activeFormWidget The active form widget associated with this form.
* This method will return the active form widget as specified by {@link activeForm}.
* @property CBaseController $owner The owner of this form. This refers to either a controller or a widget
* by which the form is created and rendered.
* @property CModel $model The model associated with this form. If this form does not have a model,
* it will look for a model in its ancestors.
* @property array $models The models that are associated with this form or its sub-forms.
* @property CFormElementCollection $elements The form elements.
* @property CFormElementCollection $buttons The form elements.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @package system.web.form
* @since 1.1
*/
class CForm extends CFormElement implements ArrayAccess
{
/**
* @var string the title for this form. By default, if this is set, a fieldset may be rendered
* around the form body using the title as its legend. Defaults to null.
*/
public $title;
/**
* @var string the description of this form.
*/
public $description;
/**
* @var string the submission method of this form. Defaults to 'post'.
* This property is ignored when this form is a sub-form.
*/
public $method='post';
/**
* @var mixed the form action URL (see {@link CHtml::normalizeUrl} for details about this parameter.)
* Defaults to an empty string, meaning the current request URL.
* This property is ignored when this form is a sub-form.
*/
public $action='';
/**
* @var string the name of the class for representing a form input element. Defaults to 'CFormInputElement'.
*/
public $inputElementClass='CFormInputElement';
/**
* @var string the name of the class for representing a form button element. Defaults to 'CFormButtonElement'.
*/
public $buttonElementClass='CFormButtonElement';
/**
* @var array HTML attribute values for the form tag. When the form is embedded within another form,
* this property will be used to render the HTML attribute values for the fieldset enclosing the child form.
*/
public $attributes=array();
/**
* @var boolean whether to show error summary. Defaults to false.
*/
public $showErrorSummary=false;
/**
* @var boolean|null whether error elements of the form attributes should be rendered. There are three possible
* valid values: null, true and false.
*
* Defaults to null meaning that {@link $showErrorSummary} will be used as value. This is done mainly to keep
* backward compatibility with existing applications. If you want to use error summary with AJAX and/or client
* validation you have to set this property to true (recall that {@link CActiveForm::error()} should be called
* for each attribute that is going to be AJAX and/or client validated).
*
* False value means that the error elements of the form attributes shall not be displayed. True value means that
* the error elements of the form attributes will be rendered.
*
* @since 1.1.14
*/
public $showErrors;
/**
* @var array the configuration used to create the active form widget.
* The widget will be used to render the form tag and the error messages.
* The 'class' option is required, which specifies the class of the widget.
* The rest of the options will be passed to {@link CBaseController::beginWidget()} call.
* Defaults to array('class'=>'CActiveForm').
* @since 1.1.1
*/
public $activeForm=array('class'=>'CActiveForm');
private $_model;
private $_elements;
private $_buttons;
private $_activeForm;
/**
* Constructor.
* If you override this method, make sure you do not modify the method
* signature, and also make sure you call the parent implementation.
* @param mixed $config the configuration for this form. It can be a configuration array
* or the path alias of a PHP script file that returns a configuration array.
* The configuration array consists of name-value pairs that are used to initialize
* the properties of this form.
* @param CModel $model the model object associated with this form. If it is null,
* the parent's model will be used instead.
* @param mixed $parent the direct parent of this form. This could be either a {@link CBaseController}
* object (a controller or a widget), or a {@link CForm} object.
* If the former, it means the form is a top-level form; if the latter, it means this form is a sub-form.
*/
public function __construct($config,$model=null,$parent=null)
{
$this->setModel($model);
if($parent===null)
$parent=Yii::app()->getController();
parent::__construct($config,$parent);
if($this->showErrors===null)
$this->showErrors=!$this->showErrorSummary;
$this->init();
}
/**
* Initializes this form.
* This method is invoked at the end of the constructor.
* You may override this method to provide customized initialization (such as
* configuring the form object).
*/
protected function init()
{
}
/**
* Returns a value indicating whether this form is submitted.
* @param string $buttonName the name of the submit button
* @param boolean $loadData whether to call {@link loadData} if the form is submitted so that
* the submitted data can be populated to the associated models.
* @return boolean whether this form is submitted.
* @see loadData
*/
public function submitted($buttonName='submit',$loadData=true)
{
$ret=$this->clicked($this->getUniqueId()) && $this->clicked($buttonName);
if($ret && $loadData)
$this->loadData();
return $ret;
}
/**
* Returns a value indicating whether the specified button is clicked.
* @param string $name the button name
* @return boolean whether the button is clicked.
*/
public function clicked($name)
{
if(strcasecmp($this->getRoot()->method,'get'))
return isset($_POST[$name]);
else
return isset($_GET[$name]);
}
/**
* Validates the models associated with this form.
* All models, including those associated with sub-forms, will perform
* the validation. You may use {@link CModel::getErrors()} to retrieve the validation
* error messages.
* @return boolean whether all models are valid
*/
public function validate()
{
$ret=true;
foreach($this->getModels() as $model)
$ret=$model->validate() && $ret;
return $ret;
}
/**
* Loads the submitted data into the associated model(s) to the form.
* This method will go through all models associated with this form and its sub-forms
* and massively assign the submitted data to the models.
* @see submitted
*/
public function loadData()
{
if($this->_model!==null)
{
$class=CHtml::modelName($this->_model);
if(strcasecmp($this->getRoot()->method,'get'))
{
if(isset($_POST[$class]))
$this->_model->setAttributes($_POST[$class]);
}
elseif(isset($_GET[$class]))
$this->_model->setAttributes($_GET[$class]);
}
foreach($this->getElements() as $element)
{
if($element instanceof self)
$element->loadData();
}
}
/**
* @return CForm the top-level form object
*/
public function getRoot()
{
$root=$this;
while($root->getParent() instanceof self)
$root=$root->getParent();
return $root;
}
/**
* @return CActiveForm the active form widget associated with this form.
* This method will return the active form widget as specified by {@link activeForm}.
* @since 1.1.1
*/
public function getActiveFormWidget()
{
if($this->_activeForm!==null)
return $this->_activeForm;
else
return $this->getRoot()->_activeForm;
}
/**
* @return CBaseController the owner of this form. This refers to either a controller or a widget
* by which the form is created and rendered.
*/
public function getOwner()
{
$owner=$this->getParent();
while($owner instanceof self)
$owner=$owner->getParent();
return $owner;
}
/**
* Returns the model that this form is associated with.
* @param boolean $checkParent whether to return parent's model if this form doesn't have model by itself.
* @return CModel the model associated with this form. If this form does not have a model,
* it will look for a model in its ancestors.
*/
public function getModel($checkParent=true)
{
if(!$checkParent)
return $this->_model;
$form=$this;
while($form->_model===null && $form->getParent() instanceof self)
$form=$form->getParent();
return $form->_model;
}
/**
* @param CModel $model the model to be associated with this form
*/
public function setModel($model)
{
$this->_model=$model;
}
/**
* Returns all models that are associated with this form or its sub-forms.
* @return array the models that are associated with this form or its sub-forms.
*/
public function getModels()
{
$models=array();
if($this->_model!==null)
$models[]=$this->_model;
foreach($this->getElements() as $element)
{
if($element instanceof self)
$models=array_merge($models,$element->getModels());
}
return $models;
}
/**
* Returns the input elements of this form.
* This includes text strings, input elements and sub-forms.
* Note that the returned result is a {@link CFormElementCollection} object, which
* means you can use it like an array. For more details, see {@link CMap}.
* @return CFormElementCollection the form elements.
*/
public function getElements()
{
if($this->_elements===null)
$this->_elements=new CFormElementCollection($this,false);
return $this->_elements;
}
/**
* Configures the input elements of this form.
* The configuration must be an array of input configuration array indexed by input name.
* Each input configuration array consists of name-value pairs that are used to initialize
* a {@link CFormStringElement} object (when 'type' is 'string'), a {@link CFormElement} object
* (when 'type' is a string ending with 'Form'), or a {@link CFormInputElement} object in
* all other cases.
* @param array $elements the elements configurations
*/
public function setElements($elements)
{
$collection=$this->getElements();
foreach($elements as $name=>$config)
$collection->add($name,$config);
}
/**
* Returns the button elements of this form.
* Note that the returned result is a {@link CFormElementCollection} object, which
* means you can use it like an array. For more details, see {@link CMap}.
* @return CFormElementCollection the form elements.
*/
public function getButtons()
{
if($this->_buttons===null)
$this->_buttons=new CFormElementCollection($this,true);
return $this->_buttons;
}
/**
* Configures the buttons of this form.
* The configuration must be an array of button configuration array indexed by button name.
* Each button configuration array consists of name-value pairs that are used to initialize
* a {@link CFormButtonElement} object.
* @param array $buttons the button configurations
*/
public function setButtons($buttons)
{
$collection=$this->getButtons();
foreach($buttons as $name=>$config)
$collection->add($name,$config);
}
/**
* Renders the form.
* The default implementation simply calls {@link renderBegin}, {@link renderBody} and {@link renderEnd}.
* @return string the rendering result
*/
public function render()
{
return $this->renderBegin() . $this->renderBody() . $this->renderEnd();
}
/**
* Renders the open tag of the form.
* The default implementation will render the open form tag.
* @return string the rendering result
*/
public function renderBegin()
{
if($this->getParent() instanceof self)
return '';
else
{
$options=$this->activeForm;
if(isset($options['class']))
{
$class=$options['class'];
unset($options['class']);
}
else
$class='CActiveForm';
$options['action']=$this->action;
$options['method']=$this->method;
if(isset($options['htmlOptions']))
{
foreach($this->attributes as $name=>$value)
$options['htmlOptions'][$name]=$value;
}
else
$options['htmlOptions']=$this->attributes;
ob_start();
$this->_activeForm=$this->getOwner()->beginWidget($class, $options);
return ob_get_clean() . "<div style=\"visibility:hidden\">".CHtml::hiddenField($this->getUniqueID(),1)."</div>\n";
}
}
/**
* Renders the close tag of the form.
* @return string the rendering result
*/
public function renderEnd()
{
if($this->getParent() instanceof self)
return '';
else
{
ob_start();
$this->getOwner()->endWidget();
return ob_get_clean();
}
}
/**
* Renders the body content of this form.
* This method mainly renders {@link elements} and {@link buttons}.
* If {@link title} or {@link description} is specified, they will be rendered as well.
* And if the associated model contains error, the error summary may also be displayed.
* The form tag will not be rendered. Please call {@link renderBegin} and {@link renderEnd}
* to render the open and close tags of the form.
* You may override this method to customize the rendering of the form.
* @return string the rendering result
*/
public function renderBody()
{
$output='';
if($this->title!==null)
{
if($this->getParent() instanceof self)
{
$attributes=$this->attributes;
unset($attributes['name'],$attributes['type']);
$output=CHtml::openTag('fieldset', $attributes)."<legend>".$this->title."</legend>\n";
}
else
$output="<fieldset>\n<legend>".$this->title."</legend>\n";
}
if($this->description!==null)
$output.="<div class=\"description\">\n".$this->description."</div>\n";
if($this->showErrorSummary && ($model=$this->getModel(false))!==null)
$output.=$this->getActiveFormWidget()->errorSummary($model)."\n";
$output.=$this->renderElements()."\n".$this->renderButtons()."\n";
if($this->title!==null)
$output.="</fieldset>\n";
return $output;
}
/**
* Renders the {@link elements} in this form.
* @return string the rendering result
*/
public function renderElements()
{
$output='';
foreach($this->getElements() as $element)
$output.=$this->renderElement($element);
return $output;
}
/**
* Renders the {@link buttons} in this form.
* @return string the rendering result
*/
public function renderButtons()
{
$output='';
foreach($this->getButtons() as $button)
$output.=$this->renderElement($button);
return $output!=='' ? "<div class=\"row buttons\">".$output."</div>\n" : '';
}
/**
* Renders a single element which could be an input element, a sub-form, a string, or a button.
* @param mixed $element the form element to be rendered. This can be either a {@link CFormElement} instance
* or a string representing the name of the form element.
* @return string the rendering result
*/
public function renderElement($element)
{
if(is_string($element))
{
if(($e=$this[$element])===null && ($e=$this->getButtons()->itemAt($element))===null)
return $element;
else
$element=$e;
}
if($element->getVisible())
{
if($element instanceof CFormInputElement)
{
if($element->type==='hidden')
return "<div style=\"visibility:hidden\">\n".$element->render()."</div>\n";
else
return "<div class=\"row field_{$element->name}\">\n".$element->render()."</div>\n";
}
elseif($element instanceof CFormButtonElement)
return $element->render()."\n";
else
return $element->render();
}
return '';
}
/**
* This method is called after an element is added to the element collection.
* @param string $name the name of the element
* @param CFormElement $element the element that is added
* @param boolean $forButtons whether the element is added to the {@link buttons} collection.
* If false, it means the element is added to the {@link elements} collection.
*/
public function addedElement($name,$element,$forButtons)
{
}
/**
* This method is called after an element is removed from the element collection.
* @param string $name the name of the element
* @param CFormElement $element the element that is removed
* @param boolean $forButtons whether the element is removed from the {@link buttons} collection
* If false, it means the element is removed from the {@link elements} collection.
*/
public function removedElement($name,$element,$forButtons)
{
}
/**
* Evaluates the visibility of this form.
* This method will check the visibility of the {@link elements}.
* If any one of them is visible, the form is considered as visible. Otherwise, it is invisible.
* @return boolean whether this form is visible.
*/
protected function evaluateVisible()
{
foreach($this->getElements() as $element)
if($element->getVisible())
return true;
return false;
}
/**
* Returns a unique ID that identifies this form in the current page.
* @return string the unique ID identifying this form
*/
protected function getUniqueId()
{
if(isset($this->attributes['id']))
return 'yform_'.$this->attributes['id'];
else
return 'yform_'.sprintf('%x',crc32(serialize(array_keys($this->getElements()->toArray()))));
}
/**
* Returns whether there is an element at the specified offset.
* This method is required by the interface ArrayAccess.
* @param mixed $offset the offset to check on
* @return boolean
*/
public function offsetExists($offset)
{
return $this->getElements()->contains($offset);
}
/**
* Returns the element at the specified offset.
* This method is required by the interface ArrayAccess.
* @param integer $offset the offset to retrieve element.
* @return mixed the element at the offset, null if no element is found at the offset
*/
public function offsetGet($offset)
{
return $this->getElements()->itemAt($offset);
}
/**
* Sets the element at the specified offset.
* This method is required by the interface ArrayAccess.
* @param integer $offset the offset to set element
* @param mixed $item the element value
*/
public function offsetSet($offset,$item)
{
$this->getElements()->add($offset,$item);
}
/**
* Unsets the element at the specified offset.
* This method is required by the interface ArrayAccess.
* @param mixed $offset the offset to unset element
*/
public function offsetUnset($offset)
{
$this->getElements()->remove($offset);
}
}

138
framework/web/form/CFormButtonElement.php Normal file
View File

@@ -0,0 +1,138 @@
<?php
/**
* CFormButtonElement class file.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @link http://www.yiiframework.com/
* @copyright 2008-2013 Yii Software LLC
* @license http://www.yiiframework.com/license/
*/
/**
* CFormButtonElement represents a form button element.
*
* CFormButtonElement can represent the following types of button based on {@link type} property:
* <ul>
* <li>htmlButton: a normal button generated using {@link CHtml::htmlButton}</li>
* <li>htmlReset a reset button generated using {@link CHtml::htmlButton}</li>
* <li>htmlSubmit: a submit button generated using {@link CHtml::htmlButton}</li>
* <li>submit: a submit button generated using {@link CHtml::submitButton}</li>
* <li>button: a normal button generated using {@link CHtml::button}</li>
* <li>image: an image button generated using {@link CHtml::imageButton}</li>
* <li>reset: a reset button generated using {@link CHtml::resetButton}</li>
* <li>link: a link button generated using {@link CHtml::linkButton}</li>
* </ul>
* The {@link type} property can also be a class name or a path alias to the class. In this case,
* the button is generated using a widget of the specified class. Note, the widget must
* have a property called "name".
*
* Because CFormElement is an ancestor class of CFormButtonElement, a value assigned to a non-existing property will be
* stored in {@link attributes} which will be passed as HTML attribute values to the {@link CHtml} method
* generating the button or initial values of the widget properties.
*
* @property string $on Scenario names separated by commas. Defaults to null.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @package system.web.form
* @since 1.1
*/
class CFormButtonElement extends CFormElement
{
/**
* @var array Core button types (alias=>CHtml method name)
*/
public static $coreTypes=array(
'htmlButton'=>'htmlButton',
'htmlSubmit'=>'htmlButton',
'htmlReset'=>'htmlButton',
'button'=>'button',
'submit'=>'submitButton',
'reset'=>'resetButton',
'image'=>'imageButton',
'link'=>'linkButton',
);
/**
* @var string the type of this button. This can be a class name, a path alias of a class name,
* or a button type alias (submit, button, image, reset, link, htmlButton, htmlSubmit, htmlReset).
*/
public $type;
/**
* @var string name of this button
*/
public $name;
/**
* @var string the label of this button. This property is ignored when a widget is used to generate the button.
*/
public $label;
private $_on;
/**
* Returns a value indicating under which scenarios this button is visible.
* If the value is empty, it means the button is visible under all scenarios.
* Otherwise, only when the model is in the scenario whose name can be found in
* this value, will the button be visible. See {@link CModel::scenario} for more
* information about model scenarios.
* @return string scenario names separated by commas. Defaults to null.
*/
public function getOn()
{
return $this->_on;
}
/**
* @param string $value scenario names separated by commas.
*/
public function setOn($value)
{
$this->_on=preg_split('/[\s,]+/',$value,-1,PREG_SPLIT_NO_EMPTY);
}
/**
* Returns this button.
* @return string the rendering result
*/
public function render()
{
$attributes=$this->attributes;
if(isset(self::$coreTypes[$this->type]))
{
$method=self::$coreTypes[$this->type];
if($method==='linkButton')
{
if(!isset($attributes['params'][$this->name]))
$attributes['params'][$this->name]=1;
}
elseif($method==='htmlButton')
{
$attributes['type']=$this->type==='htmlSubmit' ? 'submit' : ($this->type==='htmlReset' ? 'reset' : 'button');
$attributes['name']=$this->name;
}
else
$attributes['name']=$this->name;
if($method==='imageButton')
return CHtml::imageButton(isset($attributes['src']) ? $attributes['src'] : '',$attributes);
else
return CHtml::$method($this->label,$attributes);
}
else
{
$attributes['name']=$this->name;
ob_start();
$this->getParent()->getOwner()->widget($this->type, $attributes);
return ob_get_clean();
}
}
/**
* Evaluates the visibility of this element.
* This method will check the {@link on} property to see if
* the model is in a scenario that should have this string displayed.
* @return boolean whether this element is visible.
*/
protected function evaluateVisible()
{
return empty($this->_on) || in_array($this->getParent()->getModel()->getScenario(),$this->_on);
}
}

167
framework/web/form/CFormElement.php Normal file
View File

@@ -0,0 +1,167 @@
<?php
/**
* CFormElement class file.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @link http://www.yiiframework.com/
* @copyright 2008-2013 Yii Software LLC
* @license http://www.yiiframework.com/license/
*/
/**
* CFormElement is the base class for presenting all kinds of form element.
*
* CFormElement implements the way to get and set arbitrary attributes.
*
* @property boolean $visible Whether this element is visible and should be rendered.
* @property mixed $parent The direct parent of this element. This could be either a {@link CForm} object or a {@link CBaseController} object
* (a controller or a widget).
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @package system.web.form
* @since 1.1
*/
abstract class CFormElement extends CComponent
{
/**
* @var array list of attributes (name=>value) for the HTML element represented by this object.
*/
public $attributes=array();
private $_parent;
private $_visible;
/**
* Renders this element.
* @return string the rendering result
*/
abstract function render();
/**
* Constructor.
* @param mixed $config the configuration for this element.
* @param mixed $parent the direct parent of this element.
* @see configure
*/
public function __construct($config,$parent)
{
$this->configure($config);
$this->_parent=$parent;
}
/**
* Converts the object to a string.
* This is a PHP magic method.
* The default implementation simply calls {@link render} and return
* the rendering result.
* @return string the string representation of this object.
*/
public function __toString()
{
return $this->render();
}
/**
* Returns a property value or an attribute value.
* Do not call this method. This is a PHP magic method that we override
* to allow using the following syntax to read a property or attribute:
* <pre>
* $value=$element->propertyName;
* $value=$element->attributeName;
* </pre>
* @param string $name the property or attribute name
* @return mixed the property or attribute value
* @throws CException if the property or attribute is not defined
* @see __set
*/
public function __get($name)
{
$getter='get'.$name;
if(method_exists($this,$getter))
return $this->$getter();
elseif(isset($this->attributes[$name]))
return $this->attributes[$name];
else
throw new CException(Yii::t('yii','Property "{class}.{property}" is not defined.',
array('{class}'=>get_class($this), '{property}'=>$name)));
}
/**
* Sets value of a property or attribute.
* Do not call this method. This is a PHP magic method that we override
* to allow using the following syntax to set a property or attribute.
* <pre>
* $this->propertyName=$value;
* $this->attributeName=$value;
* </pre>
* @param string $name the property or attribute name
* @param mixed $value the property or attribute value
* @see __get
*/
public function __set($name,$value)
{
$setter='set'.$name;
if(method_exists($this,$setter))
$this->$setter($value);
else
$this->attributes[$name]=$value;
}
/**
* Configures this object with property initial values.
* @param mixed $config the configuration for this object. This can be an array
* representing the property names and their initial values.
* It can also be a string representing the file name of the PHP script
* that returns a configuration array.
*/
public function configure($config)
{
if(is_string($config))
$config=require(Yii::getPathOfAlias($config).'.php');
if(is_array($config))
{
foreach($config as $name=>$value)
$this->$name=$value;
}
}
/**
* Returns a value indicating whether this element is visible and should be rendered.
* This method will call {@link evaluateVisible} to determine the visibility of this element.
* @return boolean whether this element is visible and should be rendered.
*/
public function getVisible()
{
if($this->_visible===null)
$this->_visible=$this->evaluateVisible();
return $this->_visible;
}
/**
* @param boolean $value whether this element is visible and should be rendered.
*/
public function setVisible($value)
{
$this->_visible=$value;
}
/**
* @return mixed the direct parent of this element. This could be either a {@link CForm} object or a {@link CBaseController} object
* (a controller or a widget).
*/
public function getParent()
{
return $this->_parent;
}
/**
* Evaluates the visibility of this element.
* Child classes should override this method to implement the actual algorithm
* for determining the visibility.
* @return boolean whether this element is visible. Defaults to true.
*/
protected function evaluateVisible()
{
return true;
}
}

111
framework/web/form/CFormElementCollection.php Normal file
View File

@@ -0,0 +1,111 @@
<?php
/**
* CFormElementCollection class file.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @link http://www.yiiframework.com/
* @copyright 2008-2013 Yii Software LLC
* @license http://www.yiiframework.com/license/
*/
/**
* CFormElementCollection implements the collection for storing form elements.
*
* Because CFormElementCollection extends from {@link CMap}, it can be used like an associative array.
* For example,
* <pre>
* $element=$collection['username'];
* $collection['username']=array('type'=>'text', 'maxlength'=>128);
* $collection['password']=new CFormInputElement(array('type'=>'password'),$form);
* $collection[]='some string';
* </pre>
*
* CFormElementCollection can store three types of value: a configuration array, a {@link CFormElement}
* object, or a string, as shown in the above example. Internally, these values will be converted
* to {@link CFormElement} objects.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @package system.web.form
* @since 1.1
*/
class CFormElementCollection extends CMap
{
private $_form;
private $_forButtons;
/**
* Constructor.
* @param CForm $form the form object that owns this collection
* @param boolean $forButtons whether this collection is used to store buttons.
*/
public function __construct($form,$forButtons=false)
{
parent::__construct();
$this->_form=$form;
$this->_forButtons=$forButtons;
}
/**
* Adds an item to the collection.
* This method overrides the parent implementation to ensure
* only configuration arrays, strings, or {@link CFormElement} objects
* can be stored in this collection.
* @param mixed $key key
* @param mixed $value value
* @throws CException if the value is invalid.
*/
public function add($key,$value)
{
if(is_array($value))
{
if(is_string($key))
$value['name']=$key;
if($this->_forButtons)
{
$class=$this->_form->buttonElementClass;
$element=new $class($value,$this->_form);
}
else
{
if(!isset($value['type']))
$value['type']='text';
if($value['type']==='string')
{
unset($value['type'],$value['name']);
$element=new CFormStringElement($value,$this->_form);
}
elseif(!strcasecmp(substr($value['type'],-4),'form')) // a form
{
$class=$value['type']==='form' ? get_class($this->_form) : Yii::import($value['type']);
$element=new $class($value,null,$this->_form);
}
else
{
$class=$this->_form->inputElementClass;
$element=new $class($value,$this->_form);
}
}
}
elseif($value instanceof CFormElement)
{
if(property_exists($value,'name') && is_string($key))
$value->name=$key;
$element=$value;
}
else
$element=new CFormStringElement(array('content'=>$value),$this->_form);
parent::add($key,$element);
$this->_form->addedElement($key,$element,$this->_forButtons);
}
/**
* Removes the specified element by key.
* @param string $key the name of the element to be removed from the collection
*/
public function remove($key)
{
if(($item=parent::remove($key))!==null)
$this->_form->removedElement($key,$item,$this->_forButtons);
}
}

264
framework/web/form/CFormInputElement.php Normal file
View File

@@ -0,0 +1,264 @@
<?php
/**
* CFormInputElement class file.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @link http://www.yiiframework.com/
* @copyright 2008-2013 Yii Software LLC
* @license http://www.yiiframework.com/license/
*/
/**
* CFormInputElement represents form input element.
*
* CFormInputElement can represent the following types of form input based on {@link type} property:
* <ul>
* <li>text: a normal text input generated using {@link CHtml::activeTextField}</li>
* <li>hidden: a hidden input generated using {@link CHtml::activeHiddenField}</li>
* <li>password: a password input generated using {@link CHtml::activePasswordField}</li>
* <li>textarea: a text area generated using {@link CHtml::activeTextArea}</li>
* <li>file: a file input generated using {@link CHtml::activeFileField}</li>
* <li>radio: a radio button generated using {@link CHtml::activeRadioButton}</li>
* <li>checkbox: a check box generated using {@link CHtml::activeCheckBox}</li>
* <li>listbox: a list box generated using {@link CHtml::activeListBox}</li>
* <li>dropdownlist: a drop-down list generated using {@link CHtml::activeDropDownList}</li>
* <li>checkboxlist: a list of check boxes generated using {@link CHtml::activeCheckBoxList}</li>
* <li>radiolist: a list of radio buttons generated using {@link CHtml::activeRadioButtonList}</li>
* <li>url: an HTML5 url input generated using {@link CHtml::activeUrlField}</li>
* <li>email: an HTML5 email input generated using {@link CHtml::activeEmailField}</li>
* <li>number: an HTML5 number input generated using {@link CHtml::activeNumberField}</li>
* <li>range: an HTML5 range input generated using {@link CHtml::activeRangeField}</li>
* <li>date: an HTML5 date input generated using {@link CHtml::activeDateField}</li>
* </ul>
* The {@link type} property can also be a class name or a path alias to the class. In this case,
* the input is generated using a widget of the specified class. Note, the widget must
* have a property called "model" which expects a model object, and a property called "attribute"
* which expects the name of a model attribute.
*
* Because CFormElement is an ancestor class of CFormInputElement, a value assigned to a non-existing property will be
* stored in {@link attributes} which will be passed as HTML attribute values to the {@link CHtml} method
* generating the input or initial values of the widget properties.
*
* @property boolean $required Whether this input is required.
* @property string $label The label for this input. If the label is not manually set,
* this method will call {@link CModel::getAttributeLabel} to determine the label.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @package system.web.form
* @since 1.1
*/
class CFormInputElement extends CFormElement
{
/**
* @var array Core input types (alias=>CHtml method name)
*/
public static $coreTypes=array(
'text'=>'activeTextField',
'hidden'=>'activeHiddenField',
'password'=>'activePasswordField',
'textarea'=>'activeTextArea',
'file'=>'activeFileField',
'radio'=>'activeRadioButton',
'checkbox'=>'activeCheckBox',
'listbox'=>'activeListBox',
'dropdownlist'=>'activeDropDownList',
'checkboxlist'=>'activeCheckBoxList',
'radiolist'=>'activeRadioButtonList',
'url'=>'activeUrlField',
'email'=>'activeEmailField',
'number'=>'activeNumberField',
'range'=>'activeRangeField',
'date'=>'activeDateField'
);
/**
* @var string the type of this input. This can be a widget class name, a path alias of a widget class name,
* or an input type alias (text, hidden, password, textarea, file, radio, checkbox, listbox, dropdownlist, checkboxlist, or radiolist).
* If a widget class, it must extend from {@link CInputWidget} or (@link CJuiInputWidget).
*/
public $type;
/**
* @var string name of this input
*/
public $name;
/**
* @var string hint text of this input
*/
public $hint;
/**
* @var array the options for this input when it is a list box, drop-down list, check box list, or radio button list.
* Please see {@link CHtml::listData} for details of generating this property value.
*/
public $items=array();
/**
* @var array the options used when rendering the error part. This property will be passed
* to the {@link CActiveForm::error} method call as its $htmlOptions parameter.
* @see CActiveForm::error
* @since 1.1.1
*/
public $errorOptions=array();
/**
* @var boolean whether to allow AJAX-based validation for this input. Note that in order to use
* AJAX-based validation, {@link CForm::activeForm} must be configured with 'enableAjaxValidation'=>true.
* This property allows turning on or off AJAX-based validation for individual input fields.
* Defaults to true.
* @since 1.1.7
*/
public $enableAjaxValidation=true;
/**
* @var boolean whether to allow client-side validation for this input. Note that in order to use
* client-side validation, {@link CForm::activeForm} must be configured with 'enableClientValidation'=>true.
* This property allows turning on or off client-side validation for individual input fields.
* Defaults to true.
* @since 1.1.7
*/
public $enableClientValidation=true;
/**
* @var string the layout used to render label, input, hint and error. They correspond to the placeholders
* "{label}", "{input}", "{hint}" and "{error}".
*/
public $layout="{label}\n{input}\n{hint}\n{error}";
private $_label;
private $_required;
/**
* Gets the value indicating whether this input is required.
* If this property is not set explicitly, it will be determined by calling
* {@link CModel::isAttributeRequired} for the associated model and attribute of this input.
* @return boolean whether this input is required.
*/
public function getRequired()
{
if($this->_required!==null)
return $this->_required;
else
return $this->getParent()->getModel()->isAttributeRequired($this->name);
}
/**
* @param boolean $value whether this input is required.
*/
public function setRequired($value)
{
$this->_required=$value;
}
/**
* @return string the label for this input. If the label is not manually set,
* this method will call {@link CModel::getAttributeLabel} to determine the label.
*/
public function getLabel()
{
if($this->_label!==null)
return $this->_label;
else
return $this->getParent()->getModel()->getAttributeLabel($this->name);
}
/**
* @param string $value the label for this input
*/
public function setLabel($value)
{
$this->_label=$value;
}
/**
* Renders everything for this input.
* The default implementation simply returns the result of {@link renderLabel}, {@link renderInput},
* {@link renderHint}. When {@link CForm::showErrorSummary} is false, {@link renderError} is also called
* to show error messages after individual input fields.
* @return string the complete rendering result for this input, including label, input field, hint, and error.
*/
public function render()
{
if($this->type==='hidden')
return $this->renderInput();
$output=array(
'{label}'=>$this->renderLabel(),
'{input}'=>$this->renderInput(),
'{hint}'=>$this->renderHint(),
'{error}'=>!$this->getParent()->showErrors ? '' : $this->renderError(),
);
return strtr($this->layout,$output);
}
/**
* Renders the label for this input.
* The default implementation returns the result of {@link CHtml activeLabelEx}.
* @return string the rendering result
*/
public function renderLabel()
{
$options = array(
'label'=>$this->getLabel(),
'required'=>$this->getRequired()
);
if(!empty($this->attributes['id']))
{
$options['for'] = $this->attributes['id'];
}
return CHtml::activeLabel($this->getParent()->getModel(), $this->name, $options);
}
/**
* Renders the input field.
* The default implementation returns the result of the appropriate CHtml method or the widget.
* @return string the rendering result
*/
public function renderInput()
{
if(isset(self::$coreTypes[$this->type]))
{
$method=self::$coreTypes[$this->type];
if(strpos($method,'List')!==false)
return CHtml::$method($this->getParent()->getModel(), $this->name, $this->items, $this->attributes);
else
return CHtml::$method($this->getParent()->getModel(), $this->name, $this->attributes);
}
else
{
$attributes=$this->attributes;
$attributes['model']=$this->getParent()->getModel();
$attributes['attribute']=$this->name;
ob_start();
$this->getParent()->getOwner()->widget($this->type, $attributes);
return ob_get_clean();
}
}
/**
* Renders the error display of this input.
* The default implementation returns the result of {@link CHtml::error}
* @return string the rendering result
*/
public function renderError()
{
$parent=$this->getParent();
return $parent->getActiveFormWidget()->error($parent->getModel(), $this->name, $this->errorOptions, $this->enableAjaxValidation, $this->enableClientValidation);
}
/**
* Renders the hint text for this input.
* The default implementation returns the {@link hint} property enclosed in a paragraph HTML tag.
* @return string the rendering result.
*/
public function renderHint()
{
return $this->hint===null ? '' : '<div class="hint">'.$this->hint.'</div>';
}
/**
* Evaluates the visibility of this element.
* This method will check if the attribute associated with this input is safe for
* the current model scenario.
* @return boolean whether this element is visible.
*/
protected function evaluateVisible()
{
return $this->getParent()->getModel()->isAttributeSafe($this->name);
}
}

70
framework/web/form/CFormStringElement.php Normal file
View File

@@ -0,0 +1,70 @@
<?php
/**
* CFormStringElement class file.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @link http://www.yiiframework.com/
* @copyright 2008-2013 Yii Software LLC
* @license http://www.yiiframework.com/license/
*/
/**
* CFormStringElement represents a string in a form.
*
* @property string $on Scenario names separated by commas. Defaults to null.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @package system.web.form
* @since 1.1
*/
class CFormStringElement extends CFormElement
{
/**
* @var string the string content
*/
public $content;
private $_on;
/**
* Returns a value indicating under which scenarios this string is visible.
* If the value is empty, it means the string is visible under all scenarios.
* Otherwise, only when the model is in the scenario whose name can be found in
* this value, will the string be visible. See {@link CModel::scenario} for more
* information about model scenarios.
* @return string scenario names separated by commas. Defaults to null.
*/
public function getOn()
{
return $this->_on;
}
/**
* @param string $value scenario names separated by commas.
*/
public function setOn($value)
{
$this->_on=preg_split('/[\s,]+/',$value,-1,PREG_SPLIT_NO_EMPTY);
}
/**
* Renders this element.
* The default implementation simply returns {@link content}.
* @return string the string content
*/
public function render()
{
return $this->content;
}
/**
* Evaluates the visibility of this element.
* This method will check the {@link on} property to see if
* the model is in a scenario that should have this string displayed.
* @return boolean whether this element is visible.
*/
protected function evaluateVisible()
{
return empty($this->_on) || in_array($this->getParent()->getModel()->getScenario(),$this->_on);
}
}