910 lines
25 KiB
PHP
910 lines
25 KiB
PHP
<?php
|
|
/*
|
|
* $Id: Propel.php 1347 2009-12-03 21:06:36Z francois $
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* This software consists of voluntary contributions made by many individuals
|
|
* and is licensed under the LGPL. For more information please see
|
|
* <http://propel.phpdb.org>.
|
|
*/
|
|
|
|
require_once 'HTML/QuickForm.php';
|
|
|
|
define('HTML_QUICKFORM_PROPEL_NO_COLUMNS', 2);
|
|
define('HTML_QUICKFORM_PROPEL_ALL_COLUMNS', 3);
|
|
define('HTML_QUICKFORM_PROPEL_COLUMN_MADE_VISIBLE', 4);
|
|
define('HTML_QUICKFORM_PROPEL_COLUMN_MADE_HIDDEN', 5);
|
|
|
|
/* On large foreign table resultsets propel choked */
|
|
# ini_set('memory_limit', '50M');
|
|
|
|
/**
|
|
*
|
|
* NOTE: HTML_QuickForm_Propel extends HTML_QuickForm, so all QuickForm functionality is available.
|
|
*
|
|
* A fictive example:
|
|
*
|
|
* $className = 'book';
|
|
* $id = '7'; // existing item
|
|
* $id = null; // when no id is passed, it's assumed we are creating a new item
|
|
*
|
|
* $quickForm = new HTML_QuickForm_Propel($className, $id); // optionally pass it to the constructor
|
|
* $quickForm->setAction('/Bookstore/Form');
|
|
* $quickForm->addElement('header', '', 'HTML_QuickForm_Propel');
|
|
* $quickForm->setId($id);
|
|
* $quickForm->setClassName($className);
|
|
* $quickForm->setTarget('_self');
|
|
* $quickForm->setMethod('post');
|
|
*
|
|
* // use this to override the default behaviour for
|
|
* // foreign table select boxes, UserPeer::UNAME will be shown in the select list.
|
|
* // It defaults to the first string column in the foreign table.
|
|
*
|
|
* $quickForm->joinColumn(bookPeer::PUBLISHER_ID,UserPeer::UNAME);
|
|
*
|
|
* // default to all columns shown
|
|
* $quickForm->setColumnMode(HTML_QUICKFORM_PROPEL_ALL_COLUMNS);
|
|
* $quickForm->hideColumn('PASS');
|
|
*
|
|
* // or default to no columns shown
|
|
* $quickForm->setColumnMode(HTML_QUICKFORM_PROPEL_NO_COLUMNS);
|
|
* $quickForm->showColumn('NAME'); // column name without table prefix.
|
|
* $quickForm->showColumn('UNAME');
|
|
* $quickForm->showColumn('USER_INFO');
|
|
* $quickForm->showColumn('EMAIL');
|
|
* $quickForm->showColumn('FEMAIL');
|
|
* $quickForm->showColumn('URL');
|
|
* $quickForm->showColumn('PASS');
|
|
*
|
|
* // generate the form
|
|
* $quickForm->build();
|
|
*
|
|
* // after the form is build, it's possible to modify the generated elements
|
|
* $quickForm->getElement('NAME')->setSize(10); // manually tune this element
|
|
*
|
|
* if ($quickForm->validate()) {
|
|
* $quickForm->freeze();
|
|
*
|
|
* // save the object we have editted
|
|
* $quickForm->save();
|
|
* } else {
|
|
* $quickForm->toHtml(); // or any other QuickForm render option
|
|
* }
|
|
*
|
|
* TODO: map all creoleTypes to usefull formelements
|
|
*
|
|
* @author Rob Halff <info@rhalff.com>
|
|
* some improvements by Zoltan Nagy (sunshine@freemail.hu)
|
|
* @version $Rev: 1347 $
|
|
* @copyright Copyright (c) 2005 Rob Halff: LGPL - See LICENCE
|
|
* @package propel.contrib
|
|
*/
|
|
|
|
class HTML_QuickForm_Propel extends HTML_QuickForm {
|
|
|
|
/**
|
|
* ID of the Propel Object.
|
|
* @var integer
|
|
* @access private
|
|
*/
|
|
private $id;
|
|
|
|
/**
|
|
* Contains column visibility information.
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
private $columnVisibility = array();
|
|
|
|
/**
|
|
* Contains titles of columns.
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
private $columnTitle = array();
|
|
|
|
/**
|
|
* The Column visibility mode either.
|
|
* Possible values:
|
|
*
|
|
* HTML_QUICKFORM_PROPEL_ALL_COLUMNS
|
|
* HTML_QUICKFORM_PROPEL_NO_COLUMNS
|
|
*
|
|
* @var integer
|
|
* @access private
|
|
*/
|
|
private $columnMode;
|
|
|
|
/**
|
|
* String containing the peerName.
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
private $peerName;
|
|
|
|
/**
|
|
* String containing the className of the propel Object.
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
private $className;
|
|
|
|
/**
|
|
* The Column objects.
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
private $cols;
|
|
|
|
/**
|
|
* The Object being operated on.
|
|
* @var object
|
|
* @access private
|
|
*/
|
|
private $obj;
|
|
|
|
/**
|
|
* Seperator value.
|
|
*
|
|
* In case the option list will be build by multiple values
|
|
* This is the value these fields will be seperated with
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
private $seperator = ' ';
|
|
|
|
/**
|
|
*
|
|
* Not used yet.
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
private $joinMap = array();
|
|
|
|
/**
|
|
* The default QuickForm rule type to use.
|
|
* Either server or client
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
private $defaultRuleType = 'server';
|
|
|
|
|
|
/**
|
|
* This is used in the QuickForm DateElement
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
private $lang = 'en';
|
|
|
|
/**
|
|
* Rulemapping should cover all available propel rules
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
private $ruleMapping = array(
|
|
'mask'=>'regex',
|
|
'maxLength'=>'maxlength',
|
|
'minLength'=>'minlength',
|
|
'maxValue'=>'maxvalue',
|
|
'minValue'=>'minvalue',
|
|
'required'=>'required',
|
|
'validValues'=>'validvalues',
|
|
'unique'=>'unique'
|
|
);
|
|
|
|
/**
|
|
*
|
|
* CreoleType to QuickForm element mapping
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
private $typeMapping = array(
|
|
CreoleTypes::BOOLEAN =>'radio',
|
|
CreoleTypes::BIGINT =>'text',
|
|
CreoleTypes::SMALLINT =>'text',
|
|
CreoleTypes::TINYINT =>'text',
|
|
CreoleTypes::INTEGER =>'text',
|
|
CreoleTypes::NUMERIC =>'text',
|
|
CreoleTypes::DECIMAL =>'text',
|
|
CreoleTypes::REAL =>'text',
|
|
CreoleTypes::FLOAT =>'text',
|
|
CreoleTypes::DOUBLE =>'text',
|
|
CreoleTypes::CHAR =>'text',
|
|
CreoleTypes::VARCHAR =>'text',
|
|
CreoleTypes::LONGVARCHAR=>'textarea',
|
|
CreoleTypes::TEXT =>'textarea',
|
|
CreoleTypes::TIME =>'text',
|
|
CreoleTypes::TIMESTAMP =>'date',
|
|
CreoleTypes::DATE =>'date',
|
|
CreoleTypes::YEAR =>'text',
|
|
CreoleTypes::VARBINARY =>'text',
|
|
CreoleTypes::BLOB =>'text',
|
|
CreoleTypes::CLOB =>'text',
|
|
CreoleTypes::BINARY =>'text',
|
|
CreoleTypes::LONGVARBINARY=>'text',
|
|
CreoleTypes::ARR =>'text',
|
|
CreoleTypes::OTHER =>'text'
|
|
);
|
|
|
|
/**
|
|
*
|
|
* The Constructor
|
|
*
|
|
* Classname and id are specific to HTML_QuickForm_Propel
|
|
*
|
|
* The other parameters are needed to construct the parent QuickForm Class.
|
|
*
|
|
* @param string className
|
|
* @param string id
|
|
* @param string formName
|
|
* @param string method
|
|
* @param string action
|
|
* @param string target
|
|
* @param array attributes
|
|
* @param boolean trackSubmit
|
|
*
|
|
*/
|
|
public function __construct($className = null, $id = null, $formName='HTML_QuickForm_Propel', $method='post', $action='', $target='_self', $attributes=null, $trackSubmit = false)
|
|
{
|
|
$this->setClassName($className);
|
|
$this->setPeerName($className.'Peer'); // Is this always true ?
|
|
$this->setId($id);
|
|
parent::HTML_QuickForm($formName, $method, $action, $target, $attributes, $trackSubmit);
|
|
|
|
// set the default column policy
|
|
$this->setColumnMode(HTML_QUICKFORM_PROPEL_ALL_COLUMNS);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* NOT IMPLEMENTED
|
|
*
|
|
* Allows for creating complex forms.
|
|
* Note that limit 1 will always be added to the criteria.
|
|
* Because we can only edit one record/row at a time.
|
|
*
|
|
* However we will be able to join tables in complex ways.
|
|
*
|
|
* @param Criteria
|
|
*
|
|
*/
|
|
public function setCriteria(Criteria $c)
|
|
{
|
|
$c->setLimit(1);
|
|
$this->criteria = $c;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Set the action of this form
|
|
*
|
|
* @param string action
|
|
*
|
|
*/
|
|
public function setAction($action)
|
|
{
|
|
$attributes = array('action'=>$action);
|
|
$this->updateAttributes($attributes);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Set method of this form, e.g. post or get
|
|
*
|
|
* @param string method
|
|
*
|
|
*/
|
|
public function setMethod($method)
|
|
{
|
|
$attributes = array('method'=>$method);
|
|
$this->updateAttributes($attributes);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Set the target of this form
|
|
*
|
|
* @param string target
|
|
*
|
|
*/
|
|
public function setTarget($target)
|
|
{
|
|
$attributes = array('target'=>$target);
|
|
$this->updateAttributes($attributes);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Set the id of the object we need to get
|
|
*
|
|
* @param string id
|
|
*
|
|
*/
|
|
public function setId($id)
|
|
{
|
|
$this->id = $id;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Set the class
|
|
*
|
|
* @param string className
|
|
*
|
|
*/
|
|
public function setClassName($className)
|
|
{
|
|
$this->className = $className;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Get the class name
|
|
*
|
|
* @return string className
|
|
*
|
|
*/
|
|
public function getClassName()
|
|
{
|
|
return $this->className;
|
|
}
|
|
|
|
private function setPeerName($peerName)
|
|
{
|
|
$this->peerName = $peerName;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Get the peer name
|
|
*
|
|
* @return string peerName
|
|
*
|
|
*/
|
|
public function getPeerName()
|
|
{
|
|
return $this->peerName;
|
|
}
|
|
|
|
/**
|
|
* Build the form
|
|
*
|
|
* @return void
|
|
*
|
|
*/
|
|
public function build()
|
|
{
|
|
|
|
if (!class_exists($this->peerName)) {
|
|
// some autoloading, dunno if it should belong here.
|
|
// or in the users autoload function
|
|
//$dbMap = call_user_func(array($this->peerName, 'getMapBuilder'));
|
|
// TODO: implement this.
|
|
}
|
|
|
|
if (empty($this->id)) {
|
|
// create empty instance of this class
|
|
$this->obj = new $this->className();
|
|
} else {
|
|
// find the object.
|
|
if (!$this->obj = call_user_func(array($this->peerName, 'retrieveByPK'), $this->id)) {
|
|
// for help me god.. what to do ?
|
|
throw new PropelException("HTML_QuickForm_Propel::build(): $this->peerName::retrieveByPK($this->id) failed.");
|
|
}
|
|
|
|
}
|
|
|
|
// note: getTableMap is protected by default.
|
|
// so do this handstand to get the tableMap
|
|
$mapBuilder = call_user_func(array($this->peerName, 'getMapBuilder'));
|
|
|
|
// Note: $dbMap is re-used below to determine foreign table
|
|
$dbMap = $mapBuilder->getDatabaseMap();
|
|
|
|
// Get the column names for this table.
|
|
$this->cols = $dbMap->getTable(constant("$this->peerName::TABLE_NAME"))->getColumns();
|
|
|
|
// Do it the HTML_QuickForm way and use defaultValues
|
|
// instead of setValue() on every element.
|
|
// we have to first loop through the columns
|
|
foreach ($this->cols as $colName=>$col) {
|
|
|
|
|
|
$elementType = $this->typeMapping[$col->getCreoleType()];
|
|
|
|
if ($elementType == 'date') {
|
|
// null returns timestamp
|
|
$value = $this->obj->{'get'.$col->getPhpName()}(null);
|
|
} else {
|
|
|
|
$value = $this->obj->{'get'.$col->getPhpName()}();
|
|
|
|
}
|
|
|
|
$defaultValues[$colName] = $value;
|
|
}
|
|
|
|
$this->setDefaults($defaultValues);
|
|
|
|
foreach ($this->cols as $colName=>$col) {
|
|
|
|
if ($this->isColumnHidden($colName)) {
|
|
continue;
|
|
}
|
|
|
|
if ($col->isPrimaryKey()) {
|
|
// create a hidden field with primary key
|
|
if (!$this->checkColumn($colName, HTML_QUICKFORM_PROPEL_COLUMN_MADE_VISIBLE)) {
|
|
$this->addElement('hidden', $col->getColumnName(), $col->getColumnName());
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// element's title
|
|
$colTitle = $this->getColumnTitle($colName);
|
|
|
|
if ($col->isForeignKey()) {
|
|
|
|
// TODO: check if user created an optional method for populating the select form
|
|
// this populating of the select box is just some way to show joined items in a form.
|
|
// it could also be checkboxes, radio buttons or whatever kind of widget.
|
|
|
|
$relatedTable = $dbMap->getTable($col->getRelatedTableName());
|
|
$relatedCols = $relatedTable->getColumns();
|
|
$relatedPeer = $relatedTable->getPhpName().'Peer';
|
|
|
|
if (is_callable($relatedPeer, 'doSelect')) {
|
|
|
|
|
|
// TODO: allow set this criteria.
|
|
$c = new Criteria;
|
|
|
|
$relatedList = call_user_func(array($relatedPeer,'doSelect'), $c);
|
|
|
|
$colConstant = constant($this->peerName.'::'.$colName);
|
|
//$relatedColConstant = constant($relatedPeer.'::'.$relatedCol->getColumnName());
|
|
$relatedGetter = 'getPrimaryKey';
|
|
|
|
|
|
// TODO: this needs to be array based, to support multiple foreign columns
|
|
if (isset($this->joinMap[$colConstant])) {
|
|
// translate to getter
|
|
$relatedColConstant = $this->joinMap[$colConstant];
|
|
if (!$relatedTable->containsColumn($relatedColConstant)) {
|
|
// throw exception, there is no such column
|
|
throw new PropelException('HTML_QuickForm_Propel::build(): there is no column named '.$relatedTable->normalizeColName($relatedConstant).'in '.$relatedTable->getTableName().' while trying to build the select list');
|
|
}
|
|
$nameColumn = $relatedTable->getColumn($relatedColConstant);
|
|
$relatedGetter = 'get'.$nameColumn->getPhpName();
|
|
} else {
|
|
//auto detection
|
|
// determine the first string column
|
|
foreach ($relatedCols as $relatedCol) {
|
|
if ($relatedCol->getType() == 'string') {
|
|
$relatedGetter = 'get'.$relatedCol->getPhpName();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
$selectList = array();
|
|
|
|
// TODO: not hardcoded here.
|
|
$selectList[null] = _('Please selection an option');
|
|
|
|
foreach ($relatedList as $relObj) {
|
|
$key = $relObj->getPrimaryKey();
|
|
|
|
if (false OR $yesWannaUseEntireObjectsToUseItInTemplate) {
|
|
// TODO: IMPLEMENT THIS.
|
|
$selectList[$key] = $relObj;
|
|
} elseif (false OR $forceSomeKindOfColumnToBeDisplayed) {
|
|
// TODO: IMPLEMENT THIS.
|
|
} else {
|
|
$selectList[$key] = $relObj->{$relatedGetter}();
|
|
}
|
|
}
|
|
|
|
if (count($selectList) > 1) { // value of 1 depends on select message being set.
|
|
$select =& $this->addElement('select', $colName, $colTitle, $selectList);
|
|
} else {
|
|
// what to do if no records exists in the foreign table ?
|
|
$this->addElement('static', $colName, $colTitle, _('No Records'));
|
|
}
|
|
|
|
}
|
|
|
|
// do some recursion ?
|
|
|
|
} else {
|
|
|
|
//TODO: the mapping is not so generic anymore (to many exceptions)
|
|
$elementType = $this->typeMapping[$col->getCreoleType()];
|
|
|
|
if ($col->getCreoleType() == CreoleTypes::BOOLEAN) {
|
|
// TODO: describe how to override these options.
|
|
$radio = array();
|
|
$radio[] = HTML_QuickForm::createElement('radio', null, null, 'Yes', true);
|
|
$radio[] = HTML_QuickForm::createElement('radio', null, null, 'No', false);
|
|
$el = $this->addGroup($radio, $colName, $colName);
|
|
|
|
|
|
} else {
|
|
|
|
$el = $this->addElement(
|
|
$elementType,
|
|
$colName,
|
|
$colTitle);
|
|
|
|
if ($elementType == 'text') {
|
|
$el->setMaxLength($col->getSize());
|
|
}
|
|
|
|
if ($col->getCreoleType() == CreoleTypes::TIMESTAMP) {
|
|
|
|
/* Option Info:
|
|
var $_options = array(
|
|
'language' => 'en',
|
|
'format' => 'dMY',
|
|
'minYear' => 2001,
|
|
'maxYear' => 2010,
|
|
'addEmptyOption' => false,
|
|
'emptyOptionValue' => '',
|
|
'emptyOptionText' => ' ',
|
|
'optionIncrement' => array('i' => 1, 's' => 1)
|
|
);
|
|
*/
|
|
|
|
// hmm, don't like it but there seems to be no public method
|
|
// to set an option afterwards
|
|
$el->_options['language'] = $this->lang;
|
|
// TODO: is the format always the same in propel ?
|
|
$el->_options['format'] = 'Y-F-d H:i:s';
|
|
|
|
}
|
|
|
|
}
|
|
// add an html id to the element
|
|
$this->addElementId($el, $colName);
|
|
|
|
//$el->setValue($value);
|
|
|
|
// required rule for NOT NULL columns
|
|
if ($col->isNotNull()) {
|
|
// TODO: What error message should we use?
|
|
$this->addRule($colName,
|
|
$this->getColumnTitle($colName) . ' is required',
|
|
'required');
|
|
}
|
|
|
|
if ($col->hasValidators()) {
|
|
|
|
foreach ($col->getValidators() as $validatorMap) {
|
|
|
|
$this->addRule($colName,
|
|
$validatorMap->getMessage(),
|
|
$this->ruleMapping[$validatorMap->getName()],
|
|
$validatorMap->getValue(),
|
|
$this->defaultRuleType
|
|
);
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// should HTML_QuickForm_Propel add this ?
|
|
$this->addElement('submit', 'submit', 'Submit');
|
|
|
|
// do this for the developer, can't think of any case where this is unwanted.
|
|
$this->applyFilter('__ALL__', 'trim');
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Use it to change the locale used for the Date element
|
|
*
|
|
* @param string locale
|
|
* @return void
|
|
*
|
|
*/
|
|
public function setLang($lang)
|
|
{
|
|
$this->lang = $lang;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Save the form.
|
|
*
|
|
* @return void
|
|
*
|
|
*/
|
|
public function save()
|
|
{
|
|
$this->copyToObj();
|
|
$this->obj->save();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Copy form values to Obj.
|
|
*
|
|
* @return void
|
|
*
|
|
*/
|
|
public function copyToObj()
|
|
{
|
|
// TODO: check what process does, if we leave out anything important.
|
|
|
|
if (!isset($this->cols)) {
|
|
// throw some error, form cannot be saved before it is build.
|
|
throw new PropelException('HTML_QuickForm_Propel::save(): form cannot be saved before it is build.');
|
|
}
|
|
|
|
foreach ($this->cols as $colName=>$col) {
|
|
|
|
// Has the form got this element?
|
|
if ($this->isColumnHidden($colName))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
$value = $this->getElementValue($colName);
|
|
if ($value instanceof HTML_QuickForm_Error)
|
|
{
|
|
// TODO: What should we do if an error has occured?
|
|
continue;
|
|
}
|
|
$elementType = $this->typeMapping[$col->getCreoleType()];
|
|
|
|
// quickform doesn't seem to give back a timestamp, so calculate the date manually.
|
|
if ($elementType == 'date') {
|
|
|
|
$date = array(
|
|
'D' => null,
|
|
'l' => null,
|
|
'd' => null,
|
|
'M' => null,
|
|
'm' => null,
|
|
'F' => null,
|
|
'Y' => null,
|
|
'y' => null,
|
|
'h' => null,
|
|
'H' => null,
|
|
'i' => null,
|
|
's' => null,
|
|
'a' => null,
|
|
'A' => null
|
|
);
|
|
|
|
foreach ($value as $key=>$val) {
|
|
$date[$key] = $val[0];
|
|
|
|
}
|
|
|
|
$value = mktime($date['h'], $date['m'], $date['s'], $date['M'], $date['d'], $date['Y']);
|
|
}
|
|
|
|
$this->obj->{'set'.$col->getPhpName()}($value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Get the object we are operating on.
|
|
*
|
|
* @return object a propel object
|
|
*
|
|
*/
|
|
public function getObj()
|
|
{
|
|
return $this->obj;
|
|
}
|
|
|
|
/**
|
|
* What to do if a delete button is added
|
|
* and the user clicks on it, after the object has been delete in save()
|
|
*/
|
|
public function onDelete()
|
|
{
|
|
|
|
|
|
}
|
|
|
|
public function createDeleteButton()
|
|
{
|
|
return $this->addElement('submit', 'delete', 'Delete');
|
|
}
|
|
|
|
public function isColumnHidden($column)
|
|
{
|
|
if ($this->checkColumn($column, HTML_QUICKFORM_PROPEL_COLUMN_MADE_HIDDEN) && $this->columnMode == HTML_QUICKFORM_PROPEL_ALL_COLUMNS) {
|
|
return true;
|
|
}
|
|
|
|
if (!$this->checkColumn($column, HTML_QUICKFORM_PROPEL_COLUMN_MADE_VISIBLE) && $this->columnMode == HTML_QUICKFORM_PROPEL_NO_COLUMNS) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private function checkColumn($column, $state)
|
|
{
|
|
if (isset($this->columnVisibility[$column])) {
|
|
return ($this->columnVisibility[$column] == $state);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets the default visibility mode
|
|
*
|
|
* This must be either:
|
|
* HTML_QUICKFORM_PROPEL_NO_COLUMNS or
|
|
* HTML_QUICKFORM_PROPEL_ALL_COLUMNS
|
|
*
|
|
* @param string $column column name
|
|
* @return void
|
|
*
|
|
*/
|
|
public function setColumnMode($mode)
|
|
{
|
|
|
|
if ($mode != HTML_QUICKFORM_PROPEL_NO_COLUMNS && $mode != HTML_QUICKFORM_PROPEL_ALL_COLUMNS) {
|
|
|
|
throw new PropelException('HTML_QuickForm_Propel::setColumnMode(): invalid mode passed.');
|
|
|
|
}
|
|
|
|
$this->columnMode = $mode;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Tell HTML_QuickForm_Propel it should hide this column
|
|
* It is now passed like ID instead of somePeer::ID
|
|
* The latter is better, but the array_keys of the columns are in ID format and not somePeer::ID
|
|
*
|
|
* @param string $column column name
|
|
* @return void
|
|
*
|
|
*/
|
|
|
|
public function hideColumn($column)
|
|
{
|
|
$this->columnVisibility[$column] = HTML_QUICKFORM_PROPEL_COLUMN_MADE_HIDDEN;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Tell HTML_QuickForm_Propel it should show this column
|
|
*
|
|
* It is now passed like ID instead of somePeer::ID
|
|
* The latter is better, but the array_keys of the columns are in ID format and not somePeer::ID
|
|
*
|
|
* @param string $column column name
|
|
* @param string $title Title for the column, not required
|
|
* @return void
|
|
*/
|
|
public function showColumn($column, $title = NULL)
|
|
{
|
|
$this->columnVisibility[$column] = HTML_QUICKFORM_PROPEL_COLUMN_MADE_VISIBLE;
|
|
if ($title !== NULL)
|
|
{
|
|
$this->setColumnTitle($column, $title);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* assign a title to the column
|
|
*
|
|
* @param string $column
|
|
* @param string $title
|
|
* @return void
|
|
*/
|
|
public function setColumnTitle($column, $title)
|
|
{
|
|
$this->columnTitles[$column] = $title;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* returns column's title
|
|
*
|
|
* @param string $column
|
|
* @return void
|
|
*/
|
|
public function getColumnTitle($column)
|
|
{
|
|
// TODO: check if $column exists
|
|
return (array_key_exists($column, $this->columnTitles))
|
|
? $this->columnTitles[$column]
|
|
: $column;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Try to automatically join all relatedTables.
|
|
* NOT IMPLEMENTED
|
|
*
|
|
* @param boolean $bool
|
|
* @return void
|
|
*/
|
|
public function autoJoin($bool)
|
|
{
|
|
$this->autoJoin = $bool;
|
|
}
|
|
|
|
/**
|
|
* Override this if you don't like the (strtolower) default
|
|
*
|
|
* @param HTML_QuickForm_Element $el
|
|
* @param string $colName
|
|
* @return void
|
|
*/
|
|
protected function addElementId($el, $colName)
|
|
{
|
|
$el->updateAttributes(array('id'=>strtolower($colName)));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Set the default rule typef
|
|
* @param string $type
|
|
* @return void
|
|
*
|
|
*/
|
|
public function setDefaultRuleType($type)
|
|
{
|
|
$this->defaultRuleType = $type;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* UNFINISHED
|
|
*
|
|
* Probably it would be nice to be able to add this to the schema xml
|
|
*
|
|
* TODO: further implement multiple columns for the select list
|
|
*
|
|
* @var colName constant
|
|
* @var foreignColName mixed (constant/array of columnName constants)
|
|
* @var $seperator string Only used if foreignColName is an array
|
|
*/
|
|
|
|
public function joinColumn($colName, $foreignColName, $seperator = null)
|
|
{
|
|
if (isset($seperator)) {
|
|
$this->seperator = $seperator;
|
|
}
|
|
$this->joinMap[$colName] = $foreignColName;
|
|
}
|
|
|
|
}
|