<?php

//--------------------------------------------------
// This source code is released under the BSD licence,
// see the end of this script for the full details.
// It was originally created by Craig Francis in 2007.
//
// http://www.craigfrancis.co.uk/features/code/phpForm/
//
//--------------------------------------------------

/***************************************************
// Example
//--------------------------------------------------

	<?php

	//--------------------------------------------------
	// Include required PHP files

		require_once('../a/php/core.php');
		require_once(ROOT . '/a/php/form.php');

	//--------------------------------------------------
	// Form setup

		$form =& new form();
		//$form->setFormMethod('REQUEST');
		//$form->setDatabaseTable(DB_T_PREFIX . 'example_table');
		//$form->setRequiredMarkPosition(FORM_REQ_MARK_POS_RIGHT);
		//$form->setRequiredMark('HTML: &nbsp;<abbr class="required" title="Required">*</abbr>');
		//$form->setQuickPrintLabelSuffix('');

		$fldName =& new formFieldText($form, 'Name');
		$fldName->setMinLength('Your name is required.', 1);
		$fldName->setMaxLength('Your name cannot be longer than XXX characters.', 250);
		//$fldName->setDatabaseField('name');
		//$fldName->setFieldClass('myClass');
		//$fldName->setLabelClass('myClass');
		//$fldName->quickPrintShow(false);

		$fldEmail =& new formFieldEmail($form, 'Email');
		$fldEmail->setFormatError('Your email does not appear to be correct.');
		$fldEmail->setMinLength('Your email is required.', 1);
		$fldEmail->setMaxLength('Your email cannot be longer than XXX characters.', 250);

	//--------------------------------------------------
	// If the user has submitted the form

		if (isset($_POST['act']) && $_POST['act'] != '') {

			//--------------------------------------------------
			// Additional validation

				//$fldName->setError('Set the error - e.g. This username is already in use');

				//$form->addError('General form error - e.g. System error, please try again later');

			//--------------------------------------------------
			// If the data is valid

				if (!$form->hasError()) {

					//--------------------------------------------------
					// Process

						//$fldName->getValue();
						//$fldEmail->getValue();

					//--------------------------------------------------
					// Send the user onto the thank-you page

						goto('./thankYou/');

				}

			//--------------------------------------------------
			// Return the error list

				$htmlErrorList = $form->getHtmlErrorList();

		}

	//--------------------------------------------------
	// Create the form

	?>

	<form action="./" method="post" class="basicForm">
		<fieldset>

			<?= (isset($htmlErrorList) ? $htmlErrorList : '') ?>

			<!-- Start Fields -->

				<?= $form->htmlQuickPrint() ?>

			<!-- Alternative -->

				<div class="row<?= ($fldEmail->hasError() ? ' error' : '') ?>">
					<span class="label"><?= $fldEmail->getHtmlLabel() ?>:</span>
					<span class="input"><?= $fldEmail->getHtmlField() ?></span>
				</div>

			<!-- End Fields -->

			<div class="row submit">
				<input type="hidden" name="act" value="submit" />
				<input type="submit" value="Send" />
			</div>

		</fieldset>
	</form>

//--------------------------------------------------
// End of example setup
***************************************************/

//--------------------------------------------------
// Script configuration

	$GLOBALS['tplErrorListId'] = 'errorList';

//--------------------------------------------------
// Easy to use constants

	define('FORM_REQ_MARK_POS_LEFT', 0);
	define('FORM_REQ_MARK_POS_RIGHT', 1);
	define('FORM_REQ_MARK_POS_NONE', 2);

	define('FORM_DATABASE_FIELD_VALUE', 0);
	define('FORM_DATABASE_FIELD_KEY', 1);

//--------------------------------------------------
// Master form class

	class form {

		var $fields;
		var $fieldCount;
		var $formMethod;
		var $htmlErrors;
		var $htmlRequiredMark;
		var $requiredMarkPosition;
		var $hasRunPostProcessValidation;
		var $databaseTable;
		var $databaseRecordSelect;
		var $databaseFieldDetails;
		var $databaseFieldValues;
		var $quickPrintLabelSuffix;

		function form() {
			$this->fields = array();
			$this->fieldCount = 0;
			$this->formMethod = 'POST';
			$this->htmlErrors = array();
			$this->htmlRequiredMark = NULL;
			$this->requiredMarkPosition = FORM_REQ_MARK_POS_LEFT;
			$this->hasRunPostProcessValidation = false;
			$this->databaseTable = NULL;
			$this->databaseRecordSelect = NULL;
			$this->databaseFieldDetails = array();
			$this->databaseFieldValues = array();
			$this->quickPrintLabelSuffix = ':';
		}

		function setFormMethod($method) {
			$this->formMethod = $method;
		}

		function getFormMethod() {
			return $this->formMethod;
		}

		function _addField(&$fieldObj) {
			$fieldId = $this->fieldCount++;
			$this->fields[$fieldId] =& $fieldObj;
			return $fieldId;
		}

		function getFields() {
			return $this->fields;
		}

		function getField($id) {
			return $this->fields[$id];
		}

		function _htmlEncode($string) {
			if (substr($string, 0, 5) == 'HTML:') {
				if (substr($string, 5, 1) == ' ') { // Optional separating space
					return substr($string, 6);
				} else {
					return substr($string, 5);
				}
			} else {
				return html($string);
			}
		}

		function setRequiredMark($requiredMark) {
			$this->htmlRequiredMark = $this->_htmlEncode($requiredMark);
		}

		function setRequiredMarkPosition($position) {
			if ($position == FORM_REQ_MARK_POS_LEFT || $position == FORM_REQ_MARK_POS_RIGHT || $position == FORM_REQ_MARK_POS_NONE) {
				$this->requiredMarkPosition = $position;
			} else {
				exit('<p>Invalid required mark position specified - use FORM_REQ_MARK_POS_* constants</p>');
			}
		}

		function getRequiredMark($requiredMarkPosition = FORM_REQ_MARK_POS_LEFT) {
			if ($this->htmlRequiredMark !== NULL) {
				return $this->htmlRequiredMark;
			} else if ($requiredMarkPosition == FORM_REQ_MARK_POS_RIGHT) {
				return '&nbsp;<abbr class="required" title="Required">*</abbr>';
			} else {
				return '<abbr class="required" title="Required">*</abbr>&nbsp;';
			}
		}

		function getRequiredMarkPosition() {
			return $this->requiredMarkPosition;
		}

		function setQuickPrintLabelSuffix($suffix) {
			$this->quickPrintLabelSuffix = $suffix;
		}

		function _runPostProcessValidation() {

			if ($this->hasRunPostProcessValidation) {
				return NULL;
			}

			for ($fieldId = 0; $fieldId < $this->fieldCount; $fieldId++) {
				$this->fields[$fieldId]->_postProcessValidation();
			}

			$this->hasRunPostProcessValidation = true;

		}

		function getHtmlErrors() {

			$this->_runPostProcessValidation();

			$htmlErrorsFlat = array();

			for ($fieldId = -1; $fieldId < $this->fieldCount; $fieldId++) { // In field order, starting with -1 for general form errors
				if (isset($this->htmlErrors[$fieldId])) {

					foreach ($this->htmlErrors[$fieldId] as $htmlError) {
						$htmlErrorsFlat[] = $htmlError;
					}

				}
			}

			return $htmlErrorsFlat;

		}

		function getHtmlErrorList() {

			$htmlErrorsFlat = $this->getHtmlErrors();

			$htmlOutput = '';
			if (count($htmlErrorsFlat) > 0) {
				$htmlOutput = '<ul id="' . html($GLOBALS['tplErrorListId']) . '" class="error">';
				foreach ($htmlErrorsFlat as $err) $htmlOutput .= '<li>' . $err . '</li>';
				$htmlOutput .= '</ul>';
			}

			return $htmlOutput;

		}

		function _addFieldError($fieldId, $error, $hiddenInfo = NULL) {

			if (function_exists('formErrorOverride')) {
				if ($fieldId == -1) {
					$error = formErrorOverride($error, $this, NULL);
				} else {
					$error = formErrorOverride($error, $this, $this->getField($fieldId));
				}
			}

			if (!isset($this->htmlErrors[$fieldId])) {
				$this->htmlErrors[$fieldId] = array();
			}

			$htmlError = $this->_htmlEncode($error);
			if ($hiddenInfo !== NULL) {
				$htmlError .= ' <!-- ' . html($hiddenInfo) . ' -->';
			}

			$this->htmlErrors[$fieldId][] = $htmlError;

		}

		function _setFieldError($fieldId, $error, $hiddenInfo = NULL) {
			$this->htmlErrors[$fieldId] = array();
			$this->_addFieldError($fieldId, $error, $hiddenInfo);
		}

		function addError($error) {
			$this->_addFieldError(-1, $error); // -1 is for general errors, not really linked to a field
		}

		function addHtmlError($htmlError) { // Backwards compatibility
			$this->addError('HTML:' . $htmlError);
		}

		function _fieldHasError($fieldId) {
			return ($this->hasRunPostProcessValidation && isset($this->htmlErrors[$fieldId]));
		}

		function hasError() {
			$this->_runPostProcessValidation();
			return (count($this->htmlErrors) > 0);
		}

		function setDatabaseTable($sqlTable, $db = NULL) {

			//--------------------------------------------------
			// Store

				$this->databaseTable = $sqlTable;

			//--------------------------------------------------
			// Field details

				$this->databaseFields = array();

				if ($db == NULL) {
					$db = $GLOBALS['db'];
				}

				$rst = $db->query('SELECT * FROM ' . $sqlTable . ' LIMIT 0', false); // Don't return ANY data, and don't run debug (can't have it asking for "deleted" columns).

				for ($k = (mysql_num_fields($rst) - 1); $k >= 0; $k--) {

					$mysqlField = mysql_fetch_field($rst, $k);

					if (strpos(mysql_field_flags($rst, $k), 'enum') !== false) {
						$type = 'enum';
						$values = $db->enumValues($sqlTable, $mysqlField->name);
					} else {
						$type = $mysqlField->type;
						$values = NULL;
					}

					$length = mysql_field_len($rst, $k); // $mysqlField->max_length returns 0
					if ($GLOBALS['pageCharset'] == 'UTF-8' && ($type == 'blob' || $type == 'string')) {
						$length = ($length / 3);
					}

					$this->databaseFields[$mysqlField->name]['length'] = $length;
					$this->databaseFields[$mysqlField->name]['type'] = $type;
					$this->databaseFields[$mysqlField->name]['values'] = $values;

				}

		}

		function getDatabaseTable() {
			return $this->databaseTable;
		}

		function getDatabaseTableFields() {
			return $this->databaseFields;
		}

		function setDatabaseRecordSelect($sqlWhere) {
			$this->databaseRecordSelect = $sqlWhere;
		}

		function getDatabaseRecordValues($db = NULL) {

			//--------------------------------------------------
			// Validation

				if ($this->databaseTable === NULL) exit('<p>You need to call "setDatabaseTable", on the form object</p>');
				if ($this->databaseRecordSelect === NULL) exit('<p>You need to call "setDatabaseRecordSelect", on the form object</p>');

			//--------------------------------------------------
			// Fields

				$fields = array();
				for ($fieldId = 0; $fieldId < $this->fieldCount; $fieldId++) {
					if ($this->fields[$fieldId]->databaseFieldName !== NULL) {
						$fields[$fieldId] = $this->fields[$fieldId]->databaseFieldName;
					}
				}

			//--------------------------------------------------
			// Get

				if ($db == NULL) {
					$db = $GLOBALS['db'];
				}

				$db->select($this->databaseTable, $fields, $this->databaseRecordSelect);

				if ($row = $db->fetchAssoc()) {
					foreach ($row as $cField => $cValue) {
						$key = array_search($cField, $fields);
						if ($key !== false) {
							if ($this->fields[$key]->databaseFieldKey == FORM_DATABASE_FIELD_KEY) {
								$this->fields[$key]->setValueKey($cValue);
							} else {
								$this->fields[$key]->setValue($cValue);
							}
						}
					}
				}

		}

		function setDatabaseFieldValue($name, $value) {
			$this->databaseFieldValues[$name] = $value;
		}

		function databaseSave($db = NULL) {

			//--------------------------------------------------
			// Validation

				if ($this->databaseTable === NULL) exit('<p>You need to call "setDatabaseTable", on the form object</p>');

			//--------------------------------------------------
			// Values

				$values = array();

				for ($fieldId = 0; $fieldId < $this->fieldCount; $fieldId++) {
					if ($this->fields[$fieldId]->databaseFieldName !== NULL) {

						$fieldName = $this->fields[$fieldId]->databaseFieldName;
						$fieldKey = $this->fields[$fieldId]->databaseFieldKey;
						$fieldType = $this->databaseFields[$fieldName]['type'];

						if ($fieldType == 'datetime' || $fieldType == 'date') {
							$values[$fieldName] = $this->fields[$fieldId]->getValueDate();
						} else if ($fieldKey == FORM_DATABASE_FIELD_KEY) {
							$values[$fieldName] = $this->fields[$fieldId]->getValueKey();
						} else {
							$values[$fieldName] = $this->fields[$fieldId]->getValue();
						}

					}
				}

				foreach ($this->databaseFieldValues as $cName => $cValue) { // More reliable array_merge at keeping keys
					$values[$cName] = $cValue;
				}

				if (isset($this->databaseFields['edited'])) {
					$values['edited'] = date('Y-m-d H:i:s');
				}

				if (isset($this->databaseFields['created']) && $this->databaseRecordSelect === NULL) {
					$values['created'] = date('Y-m-d H:i:s');
				}

			//--------------------------------------------------
			// Save

				if ($db == NULL) {
					$db = $GLOBALS['db'];
				}

				if ($this->databaseRecordSelect === NULL) {
					$db->insert($this->databaseTable, $values);
				} else {
					$db->update($this->databaseTable, $values, $this->databaseRecordSelect);
				}

		}

		function htmlQuickPrint($fields = NULL) {

			//--------------------------------------------------
			// Print all fields, if not all provided

				if ($fields === NULL) {
					$fields =& $this->fields;
				}

			//--------------------------------------------------
			// Create the output

				$htmlOutput = '';
				foreach (array_keys($fields) as $fieldId) {
					if ($fields[$fieldId]->quickPrintShow()) {
						$htmlOutput .= $fields[$fieldId]->htmlQuickPrint();
					}
				}
				return $htmlOutput;

		}

	}

//--------------------------------------------------
// Basic form field functionality

	class formFieldBase {

		var $formObj;
		var $name;
		var $htmlLabel;
		var $htmlRequiredMark;
		var $requiredMarkPosition;
		var $required;
		var $id;
		var $cssClassField;
		var $cssClassLabel;
		var $databaseFieldName;
		var $databaseFieldKey;
		var $quickPrintShow;
		var $quickPrintType;

		function formFieldBase(&$formObj, $label, $name = NULL) {
			$this->_setup($formObj, $label, $name);
		}

		function _setup(&$formObj, $label, $name) {

			//--------------------------------------------------
			// Add this field to the form, and return a "UID"
			// NOTE: The "ID" is a string for the HTML

				$formFieldUid = $formObj->_addField($this);

			//--------------------------------------------------
			// Get the HTML label

				if (function_exists('formLabelOverride')) {
					$label = formLabelOverride($label, $this);
				}

				$this->htmlLabel = $formObj->_htmlEncode($label);

			//--------------------------------------------------
			// Field name

				if ($name === NULL) {
					$this->name = human2camel(substr($this->htmlLabel, 0, 20)) . $formFieldUid;
				} else {
					$this->name = $name;
				}

			//--------------------------------------------------
			// Field configuration

				$this->formObj =& $formObj;
				$this->formFieldUid = $formFieldUid;
				$this->htmlRequiredMark = NULL;
				$this->requiredMarkPosition = NULL;
				$this->required = false;
				$this->id = 'fld' . ucfirst($this->name);
				$this->cssClassField = NULL;
				$this->cssClassLabel = NULL;
				$this->databaseFieldName = NULL;
				$this->databaseFieldKey = FORM_DATABASE_FIELD_VALUE;
				$this->quickPrintShow = true;
				$this->quickPrintType = 'unknown';
				$this->quickPrintLabelSuffix = $formObj->quickPrintLabelSuffix;

		}

		function setRequiredMark($requiredMark) {
			$this->htmlRequiredMark = $this->formObj->_htmlEncode($requiredMark);
		}

		function setRequiredMarkPosition($position) {
			if ($position == FORM_REQ_MARK_POS_LEFT || $position == FORM_REQ_MARK_POS_RIGHT || $position == FORM_REQ_MARK_POS_NONE) {
				$this->requiredMarkPosition = $position;
			} else {
				exit('<p>Invalid required mark position specified - use FORM_REQ_MARK_POS_* constants</p>');
			}
		}

		function _setDatabaseField($fieldName, $fieldKey = FORM_DATABASE_FIELD_VALUE) {

			if (!isset($this->formObj->databaseFields[$fieldName])) {
				exit('<p>Invalid database field "' . html($fieldName) . '" set for field "' . $this->htmlLabel . '"</p>');
			}

			$this->databaseFieldName = $fieldName;
			$this->databaseFieldKey = $fieldKey;

		}

		function setDatabaseField($field) {
			$this->_setDatabaseField($field);
		}

		function getDatabaseFieldName() {
			return $this->databaseFieldName;
		}

		function getId() {
			return $this->id;
		}

		function setId($id) {
			$this->id = $id;
		}

		function getQuickPrintType() {
			return $this->quickPrintType;
		}

		function setQuickPrintLabelSuffix($suffix) {
			$this->quickPrintLabelSuffix = $suffix;
		}

		function quickPrintShow($show = NULL) {

			if ($show === true || $show === false) {
				$this->quickPrintShow = $show;
			}

			return $this->quickPrintShow;

		}

		function htmlQuickPrint() {
			$htmlOutput = '
				<div class="row ' . html($this->quickPrintType) . ($this->hasError() ? ' error' : '') . '">
					<span class="label">' . $this->getHtmlLabel() . $this->quickPrintLabelSuffix . '</span>
					<span class="input">' . $this->getHtmlField() . '</span>
				</div>' . "\n";
			return $htmlOutput;
		}

		function getName() {
			return $this->name;
		}

		function setFieldClass($cssClass) {
			$this->cssClassField = $cssClass;
		}

		function setLabelClass($cssClass) {
			$this->cssClassLabel = $cssClass;
		}

		function setHtmlLabel($htmlLabel) { // No need for 'setLabel' as this is called on init
			$this->htmlLabel = $htmlLabel;
		}

		function getTextLabel() {
			return htmlDecode($this->htmlLabel);
		}

		function getHtmlLabel($htmlLabel = NULL) {

			//--------------------------------------------------
			// Required mark position

				$requiredMarkPosition = $this->requiredMarkPosition;
				if ($requiredMarkPosition === NULL) {
					$requiredMarkPosition = $this->formObj->getRequiredMarkPosition();
				}

			//--------------------------------------------------
			// If this field is required, try to get a required
			// mark of some form

				if ($this->required) {

					$htmlRequiredMark = $this->htmlRequiredMark;

					if ($htmlRequiredMark === NULL) {
						$htmlRequiredMark = $this->formObj->getRequiredMark($requiredMarkPosition);
					}

				} else {

					$htmlRequiredMark = NULL;

				}

			//--------------------------------------------------
			// Return the HTML for the label

				return '<label for="' . html($this->id) . '"' . ($this->cssClassLabel === NULL ? '' : ' class="' . html($this->cssClassLabel) . '"') . '>' . ($requiredMarkPosition == FORM_REQ_MARK_POS_LEFT && $htmlRequiredMark !== NULL ? $htmlRequiredMark : '') . ($htmlLabel !== NULL ? $htmlLabel : $this->htmlLabel) . ($requiredMarkPosition == FORM_REQ_MARK_POS_RIGHT && $htmlRequiredMark !== NULL ? $htmlRequiredMark : '') . '</label>';

		}

		function getHtmlField() {
			return 'ERROR';
		}

		function _postProcessValidation() {
		}

		function setError($error) {
			$this->formObj->_setFieldError($this->formFieldUid, $error);
		}

		function setHtmlError($htmlError) { // Backwards compatibility
			$this->setError('HTML:' . $error);
		}

		function addError($error) {
			$this->formObj->_addFieldError($this->formFieldUid, $error);
		}

		function addHtmlError($htmlError) { // Backwards compatibility
			$this->addError('HTML:' . $htmlError);
		}

		function hasError() {
			return $this->formObj->_fieldHasError($this->formFieldUid);
		}

	}

//--------------------------------------------------
// Child text field

	class formFieldText extends formFieldBase {

		var $value;
		var $minLength;
		var $maxLength;

		function formFieldText(&$formObj, $label, $name = NULL) {
			$this->_setupText($formObj, $label, $name);
		}

		function _setupText(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setup($formObj, $label, $name);

			//--------------------------------------------------
			// Value

				$this->value = returnSubmittedValue($this->name, $formObj->getFormMethod());

			//--------------------------------------------------
			// Default configuration

				$this->minLength = 0;
				$this->maxLength = 0;
				$this->size = NULL;
				$this->quickPrintType = 'text';

		}

		function setMinLength($error, $size = 1) { // Default is "required"

			if (strlen($this->value) < $size) {
				$this->formObj->_setFieldError($this->formFieldUid, str_replace('XXX', $size, $error));
			}

			$this->minLength = $size;
			$this->required = ($size > 0);

		}

		function setMaxLength($error, $size = NULL) {

			if ($size === NULL) {

				if ($this->databaseFieldName === NULL) {
					exit('<p>You need to call "setDatabaseField", on the field "' . $this->htmlLabel . '"</p>');
				}

				$size = $this->formObj->databaseFields[$this->databaseFieldName]['length'];

			}

			if (strlen($this->value) > $size) {
				$this->formObj->_setFieldError($this->formFieldUid, str_replace('XXX', $size, $error));
			}

			$this->maxLength = $size;

		}

		function setSize($size) {
			$this->size = $size;
		}

		function setValue($value) {
			$this->value = $value;
		}

		function getValue() {
			return $this->value;
		}

		function getHtmlField() {
			return '<input type="text" name="' . html($this->name) . '" id="' . html($this->id) . '" maxlength="' . html($this->maxLength) . '" value="' . html($this->value) . '"' . ($this->size === NULL ? '' : ' size="' . intval($this->size) . '"') . ($this->cssClassField === NULL ? '' : ' class="' . html($this->cssClassField) . '"') . ' />';
		}

		function getHtmlFieldHiddenWithValue($value) {
			return '<input type="hidden" name="' . html($this->name) . '" value="' . html($value) . '" />';
		}

		function getHtmlFieldHidden() {
			return $this->getHtmlFieldHiddenWithValue($this->value);
		}

		function _postProcessValidation() {

			if ($this->maxLength == 0) {
				exit('<p>You need to call "setMaxLength", on the field "' . $this->htmlLabel . '"</p>');
			}

		}

	}

//--------------------------------------------------
// Child hidden field

	class formFieldHidden extends formFieldText {

		function formFieldHidden(&$formObj, $name) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setupText($formObj, $name, $name);

			//--------------------------------------------------
			// Default configuration

				$this->quickPrintShow = false;
				$this->quickPrintType = 'hidden';

		}

		function getHtmlLabel($htmlLabel = NULL) {
			return '';
		}

		function getHtmlField() {
			return '<input type="hidden" name="' . html($this->name) . '" value="' . html($this->value) . '" id="' . html($this->id) . '" />';
		}

	}

//--------------------------------------------------
// Child password field

	class formFieldPassword extends formFieldText {

		function formFieldPassword(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setupText($formObj, $label, $name);

			//--------------------------------------------------
			// Additional field configuration

				$this->quickPrintType = 'password';

		}

		function getHtmlField() {
			return '<input type="password" name="' . html($this->name) . '" id="' . html($this->id) . '" maxlength="' . html($this->maxLength) . '"' . ($this->size === NULL ? '' : ' size="' . intval($this->size) . '"') . ($this->cssClassField === NULL ? '' : ' class="' . html($this->cssClassField) . '"') . ' />';
		}

	}

//--------------------------------------------------
// Child text-area field

	class formFieldTextArea extends formFieldText {

		var $textareaRows;
		var $textareaCols;

		function formFieldTextArea(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setupText($formObj, $label, $name);

			//--------------------------------------------------
			// Additional field configuration

				$this->textareaRows = 5;
				$this->textareaCols = 40;
				$this->quickPrintType = 'textarea';

		}

		function setRows($rows) {
			$this->textareaRows = $rows;
		}

		function setCols($cols) {
			$this->textareaCols = $cols;
		}

		function getHtmlField() {
			return '<textarea name="' . html($this->name) . '" id="' . html($this->id) . '" rows="' . intval($this->textareaRows) . '" cols="' . intval($this->textareaCols) . '"' . ($this->cssClassField === NULL ? '' : ' class="' . html($this->cssClassField) . '"') . '>' . html($this->value) . '</textarea>';
		}

	}

//--------------------------------------------------
// Child number field

	class formFieldNumber extends formFieldText {

		var $formatErrorSet;

		function formFieldNumber(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setupText($formObj, $label, $name);

			//--------------------------------------------------
			// Additional field configuration

				$this->formatErrorSet = false;
				$this->quickPrintType = 'number';

		}

		function setFormatError($error) {

			if ($this->value != '' && !is_numeric($this->value)) {
				$this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->formatErrorSet = true;

		}

		function setRequiredError($error) {
			$this->setMinLength($error);
		}

		function setMinValue($error, $value) {

			if (floatval($this->value) < $value) {
				$this->formObj->_setFieldError($this->formFieldUid, str_replace('XXX', $value, $error));
			}

		}

		function setMaxValue($error, $value) {

			if (floatval($this->value) > $value) {
				$this->formObj->_setFieldError($this->formFieldUid, str_replace('XXX', $value, $error));
			}

			$this->maxLength = strlen($value);

			if ($this->size === NULL) {
				$this->size = $this->maxLength;
			}

		}

		function _postProcessValidation() {

			parent::_postProcessValidation();

			if ($this->formatErrorSet == false) {
				exit('<p>You need to call "setFormatError", on the field "' . $this->htmlLabel . '"</p>');
			}

		}

	}

//--------------------------------------------------
// Child email field

	class formFieldEmail extends formFieldText {

		var $formatErrorSet;

		function formFieldEmail(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setupText($formObj, $label, $name);

			//--------------------------------------------------
			// Additional field configuration

				$this->formatErrorSet = false;
				$this->quickPrintType = 'email';

		}

		function setFormatError($error) {

			if ($this->value != '' && !isemail($this->value)) {
				$this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->formatErrorSet = true;

		}

		function _postProcessValidation() {

			parent::_postProcessValidation();

			if ($this->formatErrorSet == false) {
				exit('<p>You need to call "setFormatError", on the field "' . $this->htmlLabel . '"</p>');
			}

		}

	}

//--------------------------------------------------
// Child post code field

	class formFieldPostCode extends formFieldText {

		var $formatErrorSet;

		function formFieldPostCode(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setupText($formObj, $label, $name);

			//--------------------------------------------------
			// Additional field configuration

				$this->maxLength = 8; // Bypass required setMaxLength call, and to set the <input maxlength="" />
				$this->formatErrorSet = false;
				$this->quickPrintType = 'postcode';

		}

		function setFormatError($error) {

			if ($this->value != '') {
				$postcodeClean = formatBritishPostcode($this->value);
				if ($postcodeClean === NULL) {
					$this->formObj->_setFieldError($this->formFieldUid, $error);
				}
			}

			$this->formatErrorSet = true;

		}

		function setRequiredError($error) {

			if ($this->value == '') {
				$this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->required = ($error !== NULL);

		}

		function getValue() {
			return formatBritishPostcode($this->value);
		}

		function _postProcessValidation() {

			parent::_postProcessValidation();

			if ($this->formatErrorSet == false) {
				exit('<p>You need to call "setFormatError", on the field "' . $this->htmlLabel . '"</p>');
			}

		}

	}

//--------------------------------------------------
// Child check box field

	class formFieldCheckBox extends formFieldText {

		var $textValueTrue;
		var $textValueFalse;

		function formFieldCheckBox(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setupText($formObj, $label, $name);

			//--------------------------------------------------
			// Additional field configuration

				$this->value = (returnSubmittedValue($this->name, $formObj->getFormMethod()) == 'true');
				$this->maxLength = -1; // Bypass the _postProcessValidation on the text field (not used)
				$this->quickPrintType = 'check';
				$this->quickPrintInputFirst = false;

				$this->textValueTrue = NULL;
				$this->textValueFalse = NULL;

		}

		function quickPrintInputFirst($first = NULL) {

			if ($first === true || $first === false) {
				$this->quickPrintInputFirst = $first;
			}

			return $this->quickPrintInputFirst;

		}

		function setTextValues($true, $false) {
			$this->textValueTrue = $true;
			$this->textValueFalse = $false;
		}

		function setRequiredError($error) {

			if ($this->value !== true) {
				$this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->required = ($error !== NULL);

		}

		function getHtmlField() {
			return '<input type="checkbox" name="' . html($this->name) . '" id="' . html($this->id) . '" value="true"' . ($this->value ? ' checked="checked"' : '') . ($this->cssClassField === NULL ? '' : ' class="' . html($this->cssClassField) . '"') . ' />';
		}

		function htmlQuickPrint() {
			if ($this->quickPrintInputFirst) {
				$htmlOutput = '
					<div class="row ' . html($this->quickPrintType) . ($this->hasError() ? ' error' : '') . ' inputFirst">
						<span class="input">' . $this->getHtmlField() . '</span>
						<span class="label">' . $this->getHtmlLabel() . $this->quickPrintLabelSuffix . '</span>
					</div>' . "\n";
			} else {
				$htmlOutput = '
					<div class="row ' . html($this->quickPrintType) . ($this->hasError() ? ' error' : '') . '">
						<span class="label">' . $this->getHtmlLabel() . $this->quickPrintLabelSuffix . '</span>
						<span class="input">' . $this->getHtmlField() . '</span>
					</div>' . "\n";
			}
			return $htmlOutput;
		}

		function setValue($value) {
			if ($this->textValueTrue !== NULL) {
				$this->value = ($value == $this->textValueTrue);
			} else {
				$this->value = ($value == true);
			}
		}

		function getValue() {
			if ($this->textValueTrue !== NULL) {
				return ($this->value ? $this->textValueTrue : $this->textValueFalse);
			} else {
				return $this->value;
			}
		}

	}

//--------------------------------------------------
// Child select field

	class formFieldSelect extends formFieldText {

		var $optionValues;
		var $optionKeys;
		var $labelOption;
		var $requiredErrorSet;
		var $invalidErrorSet;

		function formFieldSelect(&$formObj, $label, $name = NULL) {
			$this->_setupSelect($formObj, $label, $name);
		}

		function _setupSelect(&$formObj, $label, $name) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setupText($formObj, $label, $name);

			//--------------------------------------------------
			// Additional field configuration

				$this->value = intval($this->value);
				$this->maxLength = -1; // Bypass the _postProcessValidation on the text field (not used)
				$this->selectSize = 1;
				$this->optionValues = array();
				$this->optionKeys = array();
				$this->optGroups = NULL;
				$this->labelOption = NULL;
				$this->requiredErrorSet = false;
				$this->invalidErrorSet = false;
				$this->quickPrintType = 'select';

		}

		function setDatabaseField($field, $fieldKey = FORM_DATABASE_FIELD_VALUE) {

			$this->_setDatabaseField($field, $fieldKey);

			$fieldSetup = $this->formObj->databaseFields[$field];

			if ($fieldSetup['type'] == 'enum') {
				$this->optionValues = array_values($fieldSetup['values']);
				$this->optionKeys = array_keys($fieldSetup['values']);
			}

		}

		function setLabelOption($text = NULL) {
			$this->labelOption = $text;
		}

		function setOptions($options) {
			$this->optionValues = array_values($options);
			$this->optionKeys = array_keys($options);
		}

		function setOptGroups($optGroups) {
			$this->optGroups = $optGroups;
		}

		function setRequiredError($error) {

			if ($this->value == 0) { // Selected the "label"
				$this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->required = ($error !== NULL);
			$this->requiredErrorSet = true;

		}

		function setInvalidError($error) {

			if ($this->value != 0) { // Not selecting the "label"
				$key = ($this->value - 1);
				if (!isset($this->optionValues[$key])) {
					$this->formObj->_setFieldError($this->formFieldUid, $error);
				}
			}

			$this->invalidErrorSet = true;

		}

		function setSize($size) {
			$this->selectSize = $size;
		}

		function setValue($value) {
			$key = array_search($value, $this->optionValues);
			if ($key !== false && $key !== NULL) {
				$this->value = $key + 1;
			}
		}

		function setValueKey($value) {
			$key = array_search($value, $this->optionKeys);
			if ($key !== false && $key !== NULL) {
				$this->value = $key + 1;
			}
		}

		function getValue() {
			$key = ($this->value - 1);
			return (isset($this->optionValues[$key]) ? $this->optionValues[$key] : NULL);
		}

		function getValueKey() {
			$key = ($this->value - 1);
			return (isset($this->optionKeys[$key]) ? $this->optionKeys[$key] : NULL);
		}

		function getHtmlField() {

			$html = '
						<select name="' . html($this->name) . '" id="' . html($this->id) . '"' . ($this->selectSize <= 1 ? '' : ' size="' . intval($this->selectSize) . '"') . ($this->cssClassField === NULL ? '' : ' class="' . html($this->cssClassField) . '"') . '>';

			if ($this->labelOption !== NULL) {
				$html .= '
							<option value="0">' . ($this->labelOption === '' ? '&nbsp;' : html($this->labelOption)) . '</option>';
			}

			if ($this->optGroups === NULL) {

				foreach ($this->optionValues as $key => $option) {
					$key++; // 0 represents the labelOption
					$html .= '
							<option value="' . html($key) . '"' . ($key == $this->value ? ' selected="selected"' : '') . '>' . ($option === '' ? '&nbsp;' : html($option)) . '</option>';
				}

			} else {

				foreach (array_unique($this->optGroups) as $optGroup) {

					$html .= '
							<optgroup label="' . html($optGroup) . '">';

					foreach (array_keys($this->optGroups, $optGroup) as $key) {

						$valueKey = array_search($key, $this->optionKeys);
						if ($valueKey !== false) {
							$value = $this->optionValues[$valueKey];
						} else {
							$value = '?';
						}

						$valueKey++; // 0 represents the labelOption

						$html .= '
								<option value="' . html($valueKey) . '"' . ($valueKey == $this->value ? ' selected="selected"' : '') . '>' . ($value === '' ? '&nbsp;' : html($value)) . '</option>';

					}

					$html .= '
							</optgroup>';

				}

			}

			$html .= '
					</select>';

			return $html;

		}

		function getHtmlFieldHidden() {

			if ($this->labelOption === NULL && $this->value === 0 && count($this->optionValues) > 0) {
				return parent::getHtmlFieldHiddenWithValue(1);
			} else {
				return parent::getHtmlFieldHidden();
			}

		}

		function _postProcessValidation() {

			parent::_postProcessValidation();

			if ($this->invalidErrorSet == false) {
				$this->setInvalidError('An invalid option has been selected for "' . strtolower($this->htmlLabel) . '"');
			}

		}

	}

//--------------------------------------------------
// Child radio fields

	class formFieldRadios extends formFieldSelect {

		function formFieldRadios(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// Perform the select field setup

				$this->_setupSelect($formObj, $label, $name);

			//--------------------------------------------------
			// Additional field configuration

				$this->quickPrintType = 'radio';

		}

		function htmlQuickPrint() {
			$htmlOutput = '
				<div class="row ' . html($this->quickPrintType) . ($this->hasError() ? ' error' : '') . '">
					<span class="label">' . $this->getHtmlLabel() . $this->quickPrintLabelSuffix . '</span>';
			foreach ($this->optionKeys as $key) {
				$htmlOutput .= '
					<span class="input">
						' . $this->getHtmlFieldByKey($key) . '
						' . $this->getHtmlLabelByKey($key) . '
					</span>';
			}
			$htmlOutput .= '
				</div>' . "\n";
			return $htmlOutput;
		}

		function getHtmlLabel($htmlLabel = NULL) {
			$htmlLabel = parent::getHtmlLabel();
			$htmlLabel = preg_replace('/^<label[">]+>(.*)<\/label>$/', '$1', $htmlLabel); // Ugly, but better than duplication
			return $htmlLabel;
		}

		function getHtmlLabelByValue($value, $htmlLabel = NULL) {
			$id = array_search($value, $this->optionValues);
			if ($id !== false && $id !== NULL) {
				return $this->_getHtmlLabelById($id, $htmlLabel);
			} else {
				return 'Unknown value "' . html($value) . '"';
			}
		}

		function getHtmlLabelByKey($key, $htmlLabel = NULL) {
			$id = array_search($key, $this->optionKeys);
			if ($id !== false && $id !== NULL) {
				return $this->_getHtmlLabelById($id, $htmlLabel);
			} else if ($key === NULL) {
				return $this->_getHtmlLabelById(NULL, $htmlLabel); // labelOption
			} else {
				return 'Unknown key "' . html($key) . '"';
			}
		}

		function _getHtmlLabelById($fieldId, $htmlLabel) {

			if ($htmlLabel === NULL) {

				if ($fieldId === NULL) {
					$label = $this->labelOption;
				} else {
					$label = $this->optionValues[$fieldId];
				}

				if (function_exists('formRadioLabelOverride')) {
					$label = formRadioLabelOverride($label, $this);
				}

				$htmlLabel = $this->formObj->_htmlEncode($label);

			}

			return '<label for="' . html($this->id . '_' . ($fieldId + 1)) . '"' . ($this->cssClassLabel === NULL ? '' : ' class="' . html($this->cssClassLabel) . '"') . '>' . $htmlLabel . '</label>';

		}

		function getHtmlField() {
			return 'Please use getHtmlFieldByValue or getHtmlFieldByKey';
		}

		function getHtmlFieldByValue($value) {
			$id = array_search($value, $this->optionValues);
			if ($id !== false && $id !== NULL) {
				return $this->_getHtmlFieldById($id);
			} else {
				return 'Unknown value "' . html($value) . '"';
			}
		}

		function getHtmlFieldByKey($key) {
			$id = array_search($key, $this->optionKeys);
			if ($id !== false && $id !== NULL) {
				return $this->_getHtmlFieldById($id);
			} else if ($key === NULL) {
				return $this->_getHtmlFieldById(-1); // labelOption
			} else {
				return 'Unknown key "' . html($key) . '"';
			}
		}

		function _getHtmlFieldById($fieldId) {
			return '<input type="radio" name="' . html($this->name) . '" id="' . html($this->id . '_' . ($fieldId + 1)) . '" value="' . html($fieldId + 1) . '"' . (($fieldId + 1) == $this->value ? ' checked="checked"' : '') . ($this->cssClassField === NULL ? '' : ' class="' . html($this->cssClassField) . '"') . ' />';
		}

		function getFieldIdByValue($value) {
			$id = array_search($value, $this->optionValues);
			if ($id !== false && $id !== NULL) {
				return $this->id . '_' . ($id + 1);
			} else {
				return 'Unknown value "' . html($value) . '"';
			}
		}

		function getFieldIdByKey($key) {
			$id = array_search($key, $this->optionKeys);
			if ($id !== false && $id !== NULL) {
				return $this->id . '_' . ($id + 1);
			} else {
				return 'Unknown key "' . html($key) . '"';
			}
		}

		function _postProcessValidation() {

			parent::_postProcessValidation();

			if ($this->requiredErrorSet == false && $this->labelOption === NULL) {
				exit('<p>You need to call "setRequiredError" or "setLabelOption", on the field "' . $this->htmlLabel . '"</p>');
			}

		}


	}

//--------------------------------------------------
// Child date field

	class formFieldDate extends formFieldBase {

		var $value;
		var $valueProvided;
		var $invalidErrorSet;

		function formFieldDate(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// General setup

				$this->_setup($formObj, $label, $name);

			//--------------------------------------------------
			// Field configuration

				$this->value = array();
				$this->value['D'] = intval(returnSubmittedValue($this->name . '_D', $formObj->getFormMethod()));
				$this->value['M'] = intval(returnSubmittedValue($this->name . '_M', $formObj->getFormMethod()));
				$this->value['Y'] = intval(returnSubmittedValue($this->name . '_Y', $formObj->getFormMethod()));

				$this->valueProvided = ($this->value['D'] != 0 || $this->value['M'] != 0 || $this->value['Y'] != 0);

			//--------------------------------------------------
			// Default configuration

				$this->invalidErrorSet = false;
				$this->quickPrintType = 'date';

		}

		function htmlQuickPrint() {
			$htmlOutput = '
				<div class="row ' . html($this->quickPrintType) . ($this->hasError() ? ' error' : '') . '">
					<span class="label">' . $this->getHtmlLabel() . $this->quickPrintLabelSuffix . '</span>
					<span class="input">
						' . $this->getHtmlField('D') . '
						' . $this->getHtmlField('M') . '
						' . $this->getHtmlField('Y') . '
					</span>
					<span class="help">' . $this->getHtmlLabelForDate() . '</span>
				</div>' . "\n";
			return $htmlOutput;
		}

		function valueProvided() {
			return $this->valueProvided;
		}

		function setRequiredError($error) {

			if (!$this->valueProvided) {
				$this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->required = ($error !== NULL);

		}

		function setInvalidError($error) {

			$value = $this->getValueTimeStamp(); // Check upper bound to time-stamp, 2037 on 32bit systems

			if ($this->valueProvided && (!checkdate($this->value['M'], $this->value['D'], $this->value['Y']) || $value === false)) {
				$this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->invalidErrorSet = true;

		}

		function setMinDate($error, $timestamp) {

			if ($this->valueProvided) {

				$value = $this->getValueTimeStamp();

				if ($value !== false && $value < intval($timestamp)) {
					$this->formObj->_setFieldError($this->formFieldUid, $error);
				}

			}

		}

		function setMaxDate($error, $timestamp) {

			if ($this->valueProvided) {

				$value = $this->getValueTimeStamp();

				if ($value !== false && $value > intval($timestamp)) {
					$this->formObj->_setFieldError($this->formFieldUid, $error);
				}

			}

		}

		function setValue($value, $month = NULL, $year = NULL) {
			if ($month === NULL && $year === NULL) {

				if (!is_numeric($value)) {
					$value = strtotime($value);
					if ($value == 943920000) { // "1999-11-30 00:00:00", same as the database "0000-00-00 00:00:00"
						$value = NULL;
					}
				}

				if (is_numeric($value)) {
					$this->value['D'] = date('j', $value);
					$this->value['M'] = date('n', $value);
					$this->value['Y'] = date('Y', $value);
				}

			} else {
				$this->value['D'] = intval($value);
				$this->value['M'] = intval($month);
				$this->value['Y'] = intval($year);
			}
		}

		function getValue($part = NULL) {
			if ($part == 'D' || $part == 'M' || $part == 'Y') {
				return $this->value[$part];
			} else {
				return 'The date part must be set to "D", "M" or "Y"... or you could use getValueDate() or getValueTimeStamp()';
			}
		}

		function getValueDate() {
			return str_pad(intval($this->value['Y']), 4, '0', STR_PAD_LEFT) . '-' . str_pad(intval($this->value['M']), 2, '0', STR_PAD_LEFT) . '-' . str_pad(intval($this->value['D']), 2, '0', STR_PAD_LEFT);
		}

		function getValueTimeStamp() {
			if ($this->value['M'] == 0 && $this->value['D'] == 0 && $this->value['Y'] == 0) {
				$timestamp = false;
			} else {
				$timestamp = mktime(0, 0, 0, $this->value['M'], $this->value['D'], $this->value['Y']);
				if ($timestamp === -1) {
					$timestamp = false; // If the arguments are invalid, the function returns FALSE (before PHP 5.1 it returned -1).
				}
			}
			return $timestamp;
		}

		function getHtmlLabel($part = 'D', $htmlLabel = NULL) {

			//--------------------------------------------------
			// Check the part

				if ($part != 'D' && $part != 'M' && $part != 'Y') {
					return 'The date part must be set to "D", "M" or "Y"';
				}

			//--------------------------------------------------
			// Required mark position

				$requiredMarkPosition = $this->requiredMarkPosition;
				if ($requiredMarkPosition === NULL) {
					$requiredMarkPosition = $this->formObj->getRequiredMarkPosition();
				}

			//--------------------------------------------------
			// If this field is required, try to get a required
			// mark of some form

				if ($this->required) {

					$htmlRequiredMark = $this->htmlRequiredMark;

					if ($htmlRequiredMark === NULL) {
						$htmlRequiredMark = $this->formObj->getRequiredMark($requiredMarkPosition);
					}

				} else {

					$htmlRequiredMark = NULL;

				}

			//--------------------------------------------------
			// Return the HTML for the label

				return '<label for="' . html($this->id) . '_' . html($part) . '"' . ($this->cssClassLabel === NULL ? '' : ' class="' . html($this->cssClassLabel) . '"') . '>' . ($requiredMarkPosition == FORM_REQ_MARK_POS_LEFT && $htmlRequiredMark !== NULL ? $htmlRequiredMark : '') . ($htmlLabel !== NULL ? $htmlLabel : $this->htmlLabel) . ($requiredMarkPosition == FORM_REQ_MARK_POS_RIGHT && $htmlRequiredMark !== NULL ? $htmlRequiredMark : '') . '</label>';

		}

		function getHtmlLabelForDate($htmlSeparator = '/', $htmlDay = 'DD', $htmlMonth = 'MM', $htmlYear = 'YYYY') {
			return '<label for="' . html($this->id) . '_D">' . $htmlDay . '</label>' . $htmlSeparator . '<label for="' . html($this->id) . '_M">' . $htmlMonth . '</label>' . $htmlSeparator . '<label for="' . html($this->id) . '_Y">' . $htmlYear . '</label>';
		}

		function getHtmlField($part = NULL) {
			if ($part == 'D' || $part == 'M' || $part == 'Y') {
				return '<input type="text" name="' . html($this->name) . '_' . html($part) . '" id="' . html($this->id) . '_' . html($part) . '" maxlength="' . ($part == 'Y' ? 4 : 2) . '" size="' . ($part == 'Y' ? 4 : 2) . '" value="' . html($this->value[$part] == 0 ? '' : $this->value[$part]) . '"' . ($this->cssClassField === NULL ? '' : ' class="' . html($this->cssClassField) . '"') . ' />';
			} else {
				return 'The date part must be set to "D", "M" or "Y"';
			}
		}

		function _postProcessValidation() {

			if ($this->invalidErrorSet == false) {
				exit('<p>You need to call "setInvalidError", on the field "' . $this->htmlLabel . '"</p>');
			}

		}

	}

//--------------------------------------------------
// Child file field

	class formFieldFile extends formFieldBase {

		var $maxSize;

		var $emptyFileErrorSet;
		var $partialFileErrorSet;
		var $blankNameErrorSet;

		var $hasUploaded;

		var $valueExt;
		var $valueName;
		var $valueSize;
		var $valueMime;

		function formFieldFile(&$formObj, $label, $name = NULL) {
			$this->_setupFile($formObj, $label, $name);
		}

		function _setupFile(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setup($formObj, $label, $name);

			//--------------------------------------------------
			// Additional field configuration

				$this->quickPrintType = 'file';

			//--------------------------------------------------
			// Default validation configuration

				$this->maxSize = 0;

				$this->emptyFileErrorSet = false;
				$this->partialFileErrorSet = false;
				$this->blankNameErrorSet = false;

			//--------------------------------------------------
			// If uploaded

				$this->hasUploaded = (isset($_FILES[$this->name]) && $_FILES[$this->name]['error'] != 4); // 4 = No file was uploaded (UPLOAD_ERR_NO_FILE)

			//--------------------------------------------------
			// File values

				$this->valueExt = NULL;
				$this->valueName = NULL;
				$this->valueSize = NULL;
				$this->valueMime = NULL;

				if ($this->hasUploaded) {

					if (preg_match('/\.([a-z]+)$/i', $_FILES[$this->name]['name'], $matches)) {
						$this->valueExt = strtolower($matches[1]);
					}

					$this->valueName = $_FILES[$this->name]['name'];
					$this->valueSize = $_FILES[$this->name]['size'];
					$this->valueMime = $_FILES[$this->name]['type'];

				}

		}

		function setRequiredError($error) {

			if (!$this->hasUploaded) {
				$this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->required = ($error !== NULL);

		}

		function setMaxSize($error, $size) {

			$this->maxSize = intval($size);

			if ($this->hasUploaded) {

				$error = str_replace('XXX', fileSize2human($this->maxSize), $error);

				if ($_FILES[$this->name]['error'] == 1) $this->formObj->_setFieldError($this->formFieldUid, $error, 'ERROR: Exceeds "upload_max_filesize" ' . ini_get('upload_max_filesize'));
				if ($_FILES[$this->name]['error'] == 2) $this->formObj->_setFieldError($this->formFieldUid, $error, 'ERROR: Exceeds "MAX_FILE_SIZE" specified in the html form');

				if ($_FILES[$this->name]['size'] >= $this->maxSize) {
					$this->formObj->_setFieldError($this->formFieldUid, $error);
				}

			}

		}

		function getMaxSize() {
			return $this->maxSize;
		}

		function setPartialFileError($error) {

			if ($this->hasUploaded) {
				if ($_FILES[$this->name]['error'] == 3) $this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->partialFileErrorSet = true;

		}

		function setAllowedFileTypesMime($error, $types) {

			if ($this->hasUploaded && !in_array($this->valueMime, $types)) {
				$this->formObj->_setFieldError($this->formFieldUid, $error, 'MIME: ' . $this->valueMime);
			}

		}

		function setAllowedFileTypesExt($error, $types) {

			if ($this->hasUploaded && !in_array($this->valueExt, $types)) {
				$this->formObj->_setFieldError($this->formFieldUid, $error, 'EXT: ' . $this->valueExt);
			}

		}

		function setEmptyFileError($error) {

			if ($this->hasUploaded && $_FILES[$this->name]['size'] == 0) {
				$this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->emptyFileErrorSet = true;

		}

		function setBlankNameError($error) {

			if ($this->hasUploaded && $_FILES[$this->name]['name'] == '') {
				$this->formObj->_setFieldError($this->formFieldUid, $error);
			}

			$this->blankNameErrorSet = true;

		}

		function getHasUploaded() {
			return $this->hasUploaded;
		}

		function getValue() {
			exit('<p>Do you mean getFilePath?</p>');
		}

		function getFilePath() {
			return (!$this->hasUploaded ? NULL: $_FILES[$this->name]['tmp_name']);
		}

		function getFileExt() {
			return (!$this->hasUploaded ? NULL: $this->valueExt);
		}

		function getFileName() {
			return (!$this->hasUploaded ? NULL: $this->valueName);
		}

		function getFileSize() {
			return (!$this->hasUploaded ? NULL: $this->valueSize);
		}

		function getFileMime() {
			return (!$this->hasUploaded ? NULL: $this->valueMime);
		}

		function getHtmlField() {
			return '<input type="file" name="' . html($this->name) . '" id="' . html($this->id) . '"' . ($this->cssClassField === NULL ? '' : ' class="' . html($this->cssClassField) . '"') . ' />';
		}

		function saveFileTo($path) {
			if ($this->hasUploaded && is_writable(dirname($path))) {
				return move_uploaded_file($_FILES[$this->name]['tmp_name'], $path);
			}
			return false;
		}

		function _postProcessValidation() {

			if ($this->maxSize == 0) {
				exit('<p>You need to call "setMaxSize", on the field "' . $this->htmlLabel . '"</p>');
			}

			if (isset($_SERVER['CONTENT_TYPE']) && $_SERVER['CONTENT_TYPE'] == 'application/x-www-form-urlencoded') { // If not set, assume its correct
				exit('<p>The form needs the attribute: <strong>enctype="multipart/form-data"</strong></p>');
			}

			if ($this->emptyFileErrorSet == false) { // Provide default
				$this->setEmptyFileError('The uploaded file for "' . strtolower($this->htmlLabel) . '" is empty');
			}

			if ($this->partialFileErrorSet == false) { // Provide default
				$this->setPartialFileError('The uploaded file for "' . strtolower($this->htmlLabel) . '" was only partially uploaded');
			}

			if ($this->blankNameErrorSet == false) { // Provide default
				$this->setBlankNameError('The uploaded file for "' . strtolower($this->htmlLabel) . '" does not have a filename');
			}

		}

	}

//--------------------------------------------------
// Child file image field

	class formFieldImage extends formFieldFile {

		var $minWidthSize;
		var $maxWidthSize;
		var $minHeightSize;
		var $maxHeightSize;

		var $fileTypeErrorSet;

		var $valueImageWidth;
		var $valueImageHeight;
		var $valueImageType;

		function formFieldImage(&$formObj, $label, $name = NULL) {

			//--------------------------------------------------
			// Perform the standard field setup

				$this->_setupFile($formObj, $label, $name);

			//--------------------------------------------------
			// Additional field configuration

				$this->quickPrintType = 'image';

			//--------------------------------------------------
			// Default validation configuration

				$this->minWidthSize = 0;
				$this->maxWidthSize = 0;
				$this->minHeightSize = 0;
				$this->maxHeightSize = 0;

				$this->fileTypeErrorSet = false;

			//--------------------------------------------------
			// File values

				$this->valueImageWidth = NULL;
				$this->valueImageHeight = NULL;
				$this->valueImageType = NULL;

				if ($this->hasUploaded) {

					$dimensions = getimagesize($this->getFilePath());
					if ($dimensions !== false) {
						$this->valueImageWidth = $dimensions[0];
						$this->valueImageHeight = $dimensions[1];
						$this->valueImageType = $dimensions[2];
					}

				}

		}

		function setMinWidth($error, $size) {

			$size = intval($size);

			if ($this->valueImageWidth !== NULL && $this->valueImageWidth < $size) {
				$this->formObj->_addFieldError($this->formFieldUid, str_replace('XXX', $size . 'px', $error));
			}

			$this->minWidthSize = $size;

		}

		function setMaxWidth($error, $size) {

			$size = intval($size);

			if ($this->valueImageWidth !== NULL && $this->valueImageWidth > $size) {
				$this->formObj->_addFieldError($this->formFieldUid, str_replace('XXX', $size . 'px', $error));
			}

			$this->maxWidthSize = $size;

		}

		function setRequiredWidth($error, $size) {

			$size = intval($size);

			if ($this->valueImageWidth !== NULL && $this->valueImageWidth != $size) {
				$this->formObj->_addFieldError($this->formFieldUid, str_replace('XXX', $size . 'px', $error));
			}

			$this->minWidthSize = $size;
			$this->maxWidthSize = $size;

		}

		function getRequiredWidthMin() {
			return $this->minWidthSize;
		}

		function getRequiredWidthMax() {
			return $this->maxWidthSize;
		}

		function getRequiredWidth() {
			return $this->minWidthSize;
		}

		function setMinHeight($error, $size) {

			$size = intval($size);

			if ($this->valueImageHeight !== NULL && $this->valueImageHeight < $size) {
				$this->formObj->_addFieldError($this->formFieldUid, str_replace('XXX', $size . 'px', $error));
			}

			$this->minHeightSize = $size;

		}

		function setMaxHeight($error, $size) {

			$size = intval($size);

			if ($this->valueImageHeight !== NULL && $this->valueImageHeight > $size) {
				$this->formObj->_addFieldError($this->formFieldUid, str_replace('XXX', $size . 'px', $error));
			}

			$this->maxHeightSize = $size;

		}

		function setRequiredHeight($error, $size) {

			$size = intval($size);

			if ($this->valueImageHeight !== NULL && $this->valueImageHeight != $size) {
				$this->formObj->_addFieldError($this->formFieldUid, str_replace('XXX', $size . 'px', $error));
			}

			$this->minHeightSize = $size;
			$this->maxHeightSize = $size;

		}

		function getRequiredHeightMin() {
			return $this->minHeightSize;
		}

		function getRequiredHeightMax() {
			return $this->maxHeightSize;
		}

		function getRequiredHeight() {
			return $this->minHeightSize;
		}

		function setFileTypeError($error) {

			//--------------------------------------------------
			// Validate the mime type

				$types = array();
				$types[] = 'image/gif';
				$types[] = 'image/jpeg';
				$types[] = 'image/pjpeg'; // The wonderful world of IE
				$types[] = 'image/png';
				$types[] = 'image/x-png'; // The wonderful world of IE

				parent::setAllowedFileTypesMime($error, $types);

			//--------------------------------------------------
			// Could not use getimagesize

				if ($this->hasUploaded) {

					if ($this->valueImageType == NULL) {

						$this->formObj->_setFieldError($this->formFieldUid, $error, 'ERROR: Failed getimagesize');

					} else if ($this->valueImageType != IMAGETYPE_JPEG && $this->valueImageType != IMAGETYPE_GIF && $this->valueImageType != IMAGETYPE_PNG) {

						$this->formObj->_setFieldError($this->formFieldUid, $error, 'ERROR: Non JPG, GIF or PNG type');

					}

				}

			//--------------------------------------------------
			// Done

				$this->fileTypeErrorSet = true;

		}

		function setUnrecognisedFileType($error) { // Backwards compatibility
			$this->setFileTypeError($error);
		}

		function getImageWidth() {
			return $this->valueImageWidth;
		}

		function getImageHeight() {
			return $this->valueImageHeight;
		}

		function getImageType() {
			return $this->valueImageType;
		}

		function _postProcessValidation() {

			parent::_postProcessValidation();

			if ($this->fileTypeErrorSet == false) {
				exit('<p>You need to call "setFileTypeError", on the field "' . $this->htmlLabel . '"</p>');
			}

		}

	}

//--------------------------------------------------
// Copyright (c) 2007, Craig Francis All rights
// reserved.
//
// Redistribution and use in source and binary forms,
// with or without modification, are permitted provided
// that the following conditions are met:
//
//  * Redistributions of source code must retain the
//    above copyright notice, this list of
//    conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce
//    the above copyright notice, this list of
//    conditions and the following disclaimer in the
//    documentation and/or other materials provided
//    with the distribution.
//  * Neither the name of the author nor the names
//    of its contributors may be used to endorse or
//    promote products derived from this software
//    without specific prior written permission.
//
// 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.
//--------------------------------------------------

?>