$addFormHeader = true
[line 170]
Add a header to the form - if set to true, the form will have a header element as the first element in the form.
$booleanFields = array()
[line 486]
An array which holds the field names of those fields which are booleans.
They will be displayed as checkboxes.
$clientRules = false
[line 669]
If set to true, validation rules will also be client side.
$createSubmit = true
[line 354]
If set to false, no submit button will be created for your forms. Useful when used together with QuickForm_Controller when you already have submit buttons for next/previous page. By default, a button is being generated.
$crossLinkExtraFields = array()
[line 586]
You can also specify extra fields to edit in the a crossLink table with
this option. For example, if the user_group table mentioned above had another field called 'role' which was a text field, you could specify it like this in the user_group DataObject class: <?php
class DataObject_User_group extends DB_DataObject {
//normal stuff here
var $fb_crossLinkExtraFields = array('role');
}
?>
This would cause a text box to show up next to each checkbox in the user_group section of the form for the field 'role'.
You can specify as many fields as you want in the 'extraFields' array.
Note: If you specify a linked field in 'extraFields' you'll get a select box just like when you do a normal link field in a FormBuilder form. :-)
$crossLinks = array()
[line 561]
The crossLinks array holds data pertaining to many-many links. If you have a table which links two tables together, you can use this to automatically create a set of checkboxes or a multi-select on your form.
The simplest way of using this is: <?php
class DataObject_SomeTable extends DB_DataObject {
//...
var $fb_crossLinks = array(array('table' => 'crossLinkTable'));
}
?>
'fromField' => 'linkFieldToCurrentTable' //This is the field which links to the current (from) table
'toField' => 'linkFieldToLinkedTable' //This is the field which links to the "other" (to) table
<?php
class DataObject_SomeTable extends DB_DataObject {
//...
var $fb_crossLinks = array(array('table' => 'crossLinkTable', 'type' => 'select'));
}
?>
<?php
$fb_crossLinks = array(array('table' => 'user_group'));
?>
<?php
$fb_crossLinks = array(array('table' => 'user_group',
'fromField' => 'user_id',
'toField' => 'group_id'));
?>
<?php
$fb_crossLinks = array(array('table' => 'user_group',
'fromField' => 'group_id',
'toField' => 'user_id'));
?>
You can also specify the seperator between the elements with crossLinkSeperator.
$crossLinkSeparator = '<br/>'
[line 491]
The text to put between crosslink elements.
$dateElementFormat = 'd-m-Y'
[line 238]
A format string that represents the display settings for QuickForm date elements.
Example: "d-m-Y". See QuickForm documentation for details on format strings. Legal letters to use in the format string that work with FormBuilder are: d,m,Y,H,i,s
$dateFieldLanguage = 'en'
[line 216]
The language used in date fields. See documentation of HTML_Quickform's date element for more information.
$dateFields = array()
[line 438]
A simple array of field names indicating which of the fields in a particular table/class are actually to be treated date fields. This is an unfortunate workaround that is neccessary because the DataObject generator script does not make a difference between any other datatypes than string and integer.
When it does, this can be dropped.
$dateFromDatabaseCallback = array('DB_DataObject_FormBuilder','_date2array')
[line 223]
Callback method to convert a date from the format it is stored in the database to the format used by the QuickForm element that handles date values. Must have a format usable with call_user_func().
$dateTimeElementFormat = 'd-m-Y H:i:s'
[line 254]
A format string that represents the display settings for QuickForm datetime elements.
Example: "d-m-Y H:i:s". See QuickForm documentation for details on format strings. Legal letters to use in the format string that work with FormBuilder are: d,m,Y,H,i,s
$dateToDatabaseCallback = array('DB_DataObject_FormBuilder','_array2date')
[line 230]
Callback method to convert a date from the format used by the QuickForm element that handles date values to the format the database can store it in.
Must have a format usable with call_user_func().
$dbDateFormat = 1
[line 261]
This is for the future support of string date formats other than ISO, but currently, that's the only supported one. Set to 1 for ISO, other values may be available later on.
$elementNamePostfix = ''
[line 703]
A postfix to put after element names in the form
$elementNamePrefix = ''
[line 697]
A string to prepend to element names. Together with elementNamePostfix, this option allows you to
alter the form element names that FormBuilder uses to create and process elements. The main use for this is to combine multiple forms into one. For example, if you wanted to use multiple FB forms for the same table within one actual HTML form you could do something like this: <?php $do = DB_DataObject::factory('table'); $fb = DB_DataObject_FormBuilder::create($do); $fb->elementNamePrefix = 'formOne'; $form = $fb->getForm();
$do2 = DB_DataObject::factory('table'); $fb2 = DB_DataObject_FormBuilder::create($do2); $fb->elementNamePrefix = 'formTwo'; $fb->useForm($form); $form = $fb->getForm();
//normal processing here ?>
If you assume that "table: has one field, "name", then the resultant form will have two elements: "formOnename" and "formTwoname".
Please note: You *cannot* use '[' or ']' anywhere in the prefix or postfix. Doing so will cause FormBuilder to not be able to process the form.
$enumFields = array()
[line 466]
A simple array of fields names which should be treated as ENUMs. A select box will be created with the enum options. If you add this field to the linkElementTypes array and give it a 'radio' type, you will get radio buttons instead.
The default handler for enums is only tested in mysql. If you are using a different DB backend, use enumOptionsCallback or enumOptions.
$enumOptions = array()
[line 480]
An array which holds enum options for specific fields. Each key should be a field in the current table and each value holds a an array of strings which are the possible values for the enum. This will only be used if the field is listed in enumFields.
$enumOptionsCallback = array()
[line 472]
A valid callback which will return the options in a simple array of strings for an enum field given the table and field names.
$fieldLabels = array()
[line 361]
Array of field labels. The key of the element is the field name. Use this if you want to keep the auto-generated elements, but still define your own labels for them.
$fieldsToRender = array()
[line 368]
Array of fields to render elements for. If a field is not given, it will not be rendered. If empty, all fields will be rendered (except, normally, the primary key).
$formHeaderText = null
[line 179]
Text for the form header. If not set, the name of the database table this form represents will be used.
$hidePrimaryKey = true
[line 420]
By default, hidden fields are generated for the primary key of a DataObject. This behaviour can be deactivated by setting this option to false.
$linkDisplayFields = array()
[line 317]
These fields will be used when displaying a link record. The fields listed will be seperated by ", ". If you specify a link field as a display field and linkDisplayLevel is not 0, the link will be followed and the display fields of the record linked to displayed within parenthesis.
For example, say we have these tables:
[person]
name = 130 gender_id = 129
[gender] id = 129 name = 130
this link:
[person] gender_id = gender:id
and this data: Person: name: "Justin Patrin" gender_id: 1 Gender: id: 1 name: "male"
If person's display fields are: <?php class DataObject_Person extends DB_DataObject { //... var $fb_linkDisplayFields = array('name', 'gender_id'); } ?>
and gender's display fields are: <?php class DataObject_Gender extends DB_DataObject { //... var $fb_linkDisplayFields = array('name'); } ?>
and we set linkDisplayLevel to 0, the person record will be displayed as: "Justin Patrin, 1"
If we set linkDisplayLevel to 1, the person record will be displayed as: "Justin Patrin, (male)"
$linkDisplayLevel = 0
[line 502]
If this is set to 1 or above, links will be followed in the display fields and the display fields of the record linked to will be used for display.
If this is set to 2, links will be followed in the linked record as well. This can be set to any number of links you wish but could easily slow down your application if set to more than 1 or 2 (but only if you have links in your display fields that go that far ;-)). For a more in-depth example, see the docs for linkDisplayFields.
$linkElementTypes = array()
[line 455]
Array to configure the type of the link elements. By default, a select box will be used. The key is the name of the link element. The value is 'radio' or 'select'. If you choose 'radio', radio buttons will be made instead of a select box.
$linkOrderFields = array()
[line 342]
The fields to be used for sorting the options of an auto-generated link
element. You can specify ASC and DESC in these options as well: <?php class DataObject_SomeTable extends DB_DataObject { //... var $fb_linkOrderFields = array('field1', 'field2 DESC'); } ?>
You may also want to escape the field names if they are reserved words in the database you're using: <?php class DataObject_SomeTable extends DB_DataObject { //... function preGenerateForm() { $db = $this->getDatabaseConnection(); $this->fb_linkOrderFields = array($db->quoteIdentifier('config'), $db->quoteIdentifier('select').' DESC'); } } ?>
$preDefElements = array()
[line 401]
Array of user-defined QuickForm elements that will be used for the field
matching the array key. If no match is found, the element for that field will be auto-generated. Make your element objects either in the preGenerateForm() method or in the getForm() method. Use HTML_QuickForm::createElement() to do this.
If you wish to put in a group of elements in place of a single element, you can put an array in preDefElements instead of a single element. The name of the group will be the name of the replaced element.
$preDefGroups = array()
[line 380]
Array of groups to put certain elements in. The key is an element name, the value is the group to put the element in.
$preDefOrder = array()
[line 388]
Indexed array of element names. If defined, this will determine the order in which the form elements are being created. This is useful if you're using QuickForm's default renderer or dynamic templates and the order of the fields in the database doesn't match your needs.
$requiredRuleMessage = 'The field %s is required.'
[line 197]
Text that is displayed as an error message if a required field is left empty. Use %s to insert the field name.
$reverseLinks = array()
[line 664]
Holds reverseLink configuration.
A reverseLink is a table which links back to the current table. For example, let say we have a "gender" table which has Male and Female in it and a "person" table which has the fields "name", which holds the person's name and "genre_id" which links to the genre. If you set up a form for the gender table, the person table can be a reverseLink. The setup in the gender table would look like this: <?php
class DataObject_Gender extends DB_DataObject {
//normal stuff here
var $fb_reverseLinks = array(array('table' => 'person'));
}
?>
Say we have a person record with the name "Justin Patrin" which is linked to the gender "Male". If you view the form for the gender "Male", the checkbox next to "Justin Patrin" will be checked. If you choose the "Female" gender the checkbox will be unchecked and it will say: Justin Patrin - currently linked to - Male
If the link field is set as NOT NULL then FormBuilder will not process and unchecked checkbox unless you specify a default value to set the link to. If null is allowed, the link will be set to NULL. To specify a default value: <?php
class DataObject_Gender extends DB_DataObject {
//normal stuff here
var $fb_reverseLinks = array(array('table' => 'person',
'defaultLinkValue' => 5));
}
?>
You may also set the text which is displayed between the record and the currently linked to record. <?php
class DataObject_Gender extends DB_DataObject {
//normal stuff here
var $fb_reverseLinks = array(array('table' => 'person',
'linkText' => ' is currently listed as a '));
}
?>
$ruleViolationMessage = '%s: The value you have entered is not valid.'
[line 188]
Text that is displayed as an error message if a validation rule is violated by the user's input. Use %s to insert the field name.
$selectAddEmpty = array()
[line 408]
An array of the link or date fields which should have an empty option added to the select box. This is only a valid option for fields which link to another table or date fields.
$selectAddEmptyLabel = ''
[line 413]
An string to put in the "empty option" added to select fields
$submitText = 'Submit'
[line 347]
The caption of the submit button, if created.
$textFields = array()
[line 429]
A simple array of field names indicating which of the fields in a particular table/class are actually to be treated as textareas. This is an unfortunate workaround that is neccessary because the DataObject generator script does not make a difference between any other datatypes than string and integer.
When it does, this can be dropped.
$timeElementFormat = 'H:i:s'
[line 246]
A format string that represents the display settings for QuickForm time elements.
Example: "H:i:s". See QuickForm documentation for details on format strings. Legal letters to use in the format string that work with FormBuilder are: d,m,Y,H,i,s
$timeFields = array()
[line 447]
A simple array of field names indicating which of the fields in a particular table/class are actually to be treated time fields. This is an unfortunate workaround that is neccessary because the DataObject generator script does not make a difference between any other datatypes than string and integer.
When it does, this can be dropped.
$tripleLinks = array()
[line 600]
Holds triple link data.
The tripleLinks array can be used to display checkboxes for "triple-links". A triple link is set up with a table which links to three different tables. These will show up as a table of checkboxes The initial setting (table) is the same as for crossLinks. The field configuration keys (if you need them) are: 'fromField'
'toField1'
'toField2'
$useCallTimePassByReference = false
[line 708]
Whether or not to use call-time-pass-by-reference when calling DataObject callbacks
$userEditableFields = array()
[line 374]
Array of fields which the user can edit. If a field is rendered but not specified in this array, it will be frozen. Ignored if not given.
$validateOnProcess = false
[line 208]
If set to TRUE, the current DataObject's validate method is being called before the form data is processed. If errors occur, no insert/update operation will be made on the database. Use getValidationErrors() to retrieve the reasons for a failure.
Defaults to FALSE.
$_appendForm = false
[line 158]
If false, FormBuilder will use the form object from $_form as a basis for the new form: It will just add elements to the existing form object, not generate a new one.
If true, FormBuilder will generate a new form object, create all elements as needed for the given DataObject, then strip the elements from the exiting form object in $_form and add it to the newly generated form object.
$_form = false
[line 133]
If you want to use the generator on an existing form object, pass it to the factory method within the options array, element name: 'form' (who would have guessed?)
$_queryType = DB_DATAOBJECT_FORMBUILDER_QUERY_AUTODETECT
[line 147]
Used to determine which action to perform with the submitted data in processForm()
$_validationErrors = false
[line 140]
Contains the last validation errors, if validation checking is enabled.
DB_DataObject_FormBuilder (Constructor) [line 766]
DB_DataObject_FormBuilder DB_DataObject_FormBuilder(
&$do, [array
$options = false], object
$do)
|
|
DB_DataObject_FormBuilder::DB_DataObject_FormBuilder()
The class constructor.
Parameters:
create [line 737]
object DB_DataObject_FormBuilder &create(
&$do, [array
$options = false], [string
$driver = 'QuickForm'], object
$do)
|
|
DB_DataObject_FormBuilder::create()
Factory method. As this is meant as an abstract class, it is the only supported method to make a new object instance. Pass the DataObject-derived class you want to build a form from as the first parameter. Use the second to pass additional options.
Options can be:
- 'ruleViolationMessage' : See description of similarly-named class property
- 'requiredRuleMessage' : See description of similarly-named class property
- 'addFormHeader' : See description of similarly-named class property
- 'formHeaderText' : See description of similarly-named class property
The third parameter is the name of a driver class. A driver class will take care of the actual form generation. This way it's possible to have FormBuilder build different forms for different types of output media from the same set of DataObjects.
Currently available driver classes:
- QuickForm (stable)
- XUL (experimental!)
Parameters:
debug [line 2495]
void debug(
string
$message)
|
|
DB_DataObject_FormBuilder::debug()
Outputs a debug message, if the debug setting in the DataObject.ini file is set to 1 or higher.
Parameters:
forceQueryType [line 2469]
boolean forceQueryType(
[integer
$queryType = DB_DATAOBJECT_FORMBUILDER_QUERY_AUTODETECT])
|
|
DB_DataObject_FormBuilder::forceQueryType()
You can force the behaviour of the processForm() method by passing one of the following constants to this method:
- DB_DATAOBJECT_FORMBUILDER_QUERY_FORCEINSERT:
The submitted data will always be INSERTed into the database
- DB_DATAOBJECT_FORMBUILDER_QUERY_FORCEUPDATE:
The submitted data will always be used to perform an UPDATE on the database
- DB_DATAOBJECT_FORMBUILDER_QUERY_FORCENOACTION:
The submitted data will overwrite the properties of the DataObject, but no
action will be performed on the database.
- DB_DATAOBJECT_FORMBUILDER_QUERY_AUTODETECT:
The processForm() method will try to detect for itself if an INSERT or UPDATE
query has to be performed. This will not work if no primary key field can
be detected for the current DataObject. In this case, no action will be performed.
This is the default behaviour.
Parameters:
getDataObjectString [line 1523]
string getDataObjectString(
DB_DataObject
&$do, [mixed
$displayFields = false], [int
$linkDisplayLevel = null], [int
$level = 1])
|
|
DB_DataObject_FormBuilder::getDataObjectString()
Returns a string which identitfies this dataobject. If multiple display fields are given, will display them all seperated by ", ". If a display field is a foreign key (link) the display value for the record it points to will be used as long as the linkDisplayLevel has not been reached. Its display value will be surrounded by parenthesis as it may have multiple display fields of its own.
May be called statically.
Will use display field configurations from these locations, in this order: 1) $displayFields parameter 2) the fb_linkDisplayFields member variable of the dataobject 3) the linkDisplayFields member variable of this class (if not called statically) 4) all fields returned by the DO's table() function
Parameters:
getFieldLabel [line 1487]
string getFieldLabel(
$fieldName
$fieldName)
|
|
DB_DataObject_FormBuilder::getFieldLabel()
Returns the label for the given field name. If no label is specified, the fieldname will be returned with ucfirst() applied.
Parameters:
getFieldName [line 1353]
string getFieldName(
string
$fieldName)
|
|
Gets the name of the field to use in the form.
Parameters:
getForm [line 1723]
object &getForm(
[string
$action = false], [string
$target = '_self'], [string
$formName = false], [string
$method = 'post'])
|
|
DB_DataObject_FormBuilder::getForm()
Returns a HTML form that was automagically created by _generateForm(). You need to use the get() method before calling this one in order to prefill the form with the retrieved data.
If you have a method named "preGenerateForm()" in your DataObject-derived class, it will be called before _generateForm(). This way, you can create your own elements there and add them to the "fb_preDefElements" property, so they will not be auto-generated.
If you have your own "getForm()" method in your class, it will be called instead of _generateForm(). This enables you to have some classes that make their own forms completely from scratch, without any auto-generation. Use this for highly complex forms. Your getForm() method needs to return the complete HTML_QuickForm object by reference.
If you have a method named "postGenerateForm()" in your DataObject-derived class, it will be called after _generateForm(). This allows you to remove some elements that have been auto-generated from table fields but that you don't want in the form.
Many ways lead to rome.
Parameters:
getSelectOptions [line 1585]
array getSelectOptions(
string
$field, [string
$displayFields = false], [bool
$selectAddEmpty = false])
|
|
DB_DataObject_FormBuilder::getSelectOptions()
Returns an array of options for use with the HTML_QuickForm "select" element. It will try to fetch all related objects (if any) for the given field name and build the array. For the display name of the option, it will try to use the settings in the database.formBuilder.ini file. If those are not found, the linked object's property "fb_linkDisplayFields". If that one is not present, it will try to use the global configuration setting "linkDisplayFields". Can also be called with a second parameter containing the name of the display field - this will override all other settings. Same goes for "linkOrderFields", which determines the field name used for sorting the option elements. If neither a config setting nor a class property of that name is set, the display field name will be used.
Parameters:
getValidationErrors [line 2018]
mixed getValidationErrors(
)
|
|
DB_DataObject_FormBuilder::getValidationErrors()
Returns errors from data validation. If errors have occured, this will be an array with the fields that have errors, otherwise a boolean.
populateOptions [line 1684]
DB_DataObject_FormBuilder::populateOptions()
Populates public member vars with fb_ equivalents in the DataObject.
processForm [line 2064]
boolean processForm(
array
$values, string
$queryType)
|
|
DB_DataObject_FormBuilder::processForm()
This will take the submitted form data and put it back into the object's properties. If the primary key is not set or NULL, it will be assumed that you wish to insert a new element into the database, so DataObject's insert() method is invoked. Otherwise, an update() will be performed. <b>Careful:</b> If you're using natural keys or cross-referencing tables where you don't have
one dedicated primary key, this will always assume that you want to do an update! As there
won't be a matching entry in the table, no action will be performed at all - the reason
for this behaviour can be very hard to detect. Thus, if you have such a situation in one
of your tables, simply override this method so that instead of the key check it will try
to do a SELECT on the table using the current settings. If a match is found, do an update.
If not, do an insert. This method is perfect for use with QuickForm's process method. Example: if ($form->validate()) {
$form->freeze();
$form->process(array(&$formGenerator,'processForm'), false);
}
If you wish to enforce a special type of query, use the forceQueryType() method.
Always remember to pass your objects by reference - otherwise, if the operation was an insert, the primary key won't get updated with the new database ID because processForm() was using a local copy of the object!
If a method named "preProcessForm()" exists in your derived class, it will be called before processForm() starts doing its magic. The data that has been submitted by the form will be passed to that method as a parameter. Same goes for a method named "postProcessForm()", with the only difference - you might have guessed this by now - that it's called after the insert/update operations have been done. Use this for filtering data, notifying users of changes etc.pp. ...
Parameters:
useForm [line 1464]
boolean useForm(
$form
&$form, [$append
$append = false])
|
|
DB_DataObject_FormBuilder::useForm()
Sometimes, it might come in handy not just to create a new QuickForm object, but to work with an existing one. Using FormBuilder together with HTML_QuickForm_Controller or HTML_QuickForm_Page is such an example ;-) If you do not call this method before the form is generated, a new QuickForm object will be created (default behaviour).
Parameters:
validateData [line 2002]
DB_DataObject_FormBuilder::validateData()
Makes a call to the current DataObject's validate() method and returns the result.
_array2date [line 1934]
mixed _array2date(
$dateInput, [boolean
$timestamp = false], array
$date)
|
|
DB_DataObject_FormBuilder::_array2date()
Takes a date array as used by the QuickForm date element and turns it back into a string representation suitable for use with a database date field (format 'YYYY-MM-DD'). If second parameter is true, it will return a unix timestamp instead. //FRANK: Not at this point it wont
Beware: For the date conversion to work, you must at least use the letters "d", "m" and "Y" in your format string (see "dateElementFormat" option). If you want to enter a time as well, you will have to use "H", "i" and "s" as well. Other letters will not work! Exception: You can also use "M" instead of "m" if you want plain text month names.
Parameters:
_date2array [line 1862]
array _date2array(
mixed
$date)
|
|
DB_DataObject_FormBuilder::_date2array()
Takes a string representing a date or a unix timestamp and turns it into an array suitable for use with the QuickForm data element. When using a string, make sure the format can be handled by the PEAR::Date constructor!
Beware: For the date conversion to work, you must at least use the letters "d", "m" and "Y" in your format string (see "dateElementFormat" option). If you want to enter a time as well, you will have to use "H", "i" and "s" as well. Other letters will not work! Exception: You can also use "M" instead of "m" if you want plain text month names.
Parameters:
_explodeArrString [line 1374]
array _explodeArrString(
string
$str)
|
|
DB_DataObject_FormBuilder::_explodeArrString()
Internal method, will convert string representations of arrays as used in .ini files to real arrays. String format example: key1:value1,key2:value2,key3:value3,...
Parameters:
_generateForm [line 883]
object &_generateForm(
[string
$action = false], [string
$target = '_self'], [string
$formName = false], [string
$method = 'post'])
|
|
DB_DataObject_FormBuilder::_generateForm()
Builds a simple HTML form for the current DataObject. Internal function, called by the public getForm() method. You can override this in child classes if needed, but it's also possible to leave this as it is and just override the getForm() method to simply fine-tune the auto-generated form object (i.e. add/remove elements, alter options, add/remove rules etc.). If a key with the same name as the current field is found in the fb_preDefElements property, the QuickForm element object contained in that array will be used instead of auto-generating a new one. This allows for complete step-by-step customizing of your forms.
Note for date fields: HTML_QuickForm allows passing of an options array to the HTML_QuickForm_date element. You can define your own options array for date elements in your DataObject-derived classes by defining a method "dateOptions($fieldName)". FormBuilder will call that method whenever it encounters a date field and expects to get back a valid options array.
Parameters:
_getSelectOptions [line 1619]
array _getSelectOptions(
string
$table, [array
$displayFields = false], [bool
$selectAddEmpty = false], [string
$field = false])
|
|
Internal function to get the select potions for a table.
Parameters:
_reorderElements [line 1403]
mixed _reorderElements(
)
|
|
DB_DataObject_FormBuilder::_reorderElements()
Changes the order in which elements are being processed, so that you can use QuickForm's default renderer or dynamic templates without being dependent on the field order in the database.
Make a class property named "fb_preDefOrder" in your DataObject-derived classes which contains an array with the correct element order to use this feature.
