[BUGFIX] Fix property access for ObjectStorage

[Packages/TYPO3.CMS.git] / typo3 / sysext / backend / Classes / Form / FormEngine.php

<?php
namespace TYPO3\CMS\Backend\Form;

/**
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\CMS\Backend\Form\Element\InlineElement;
use TYPO3\CMS\Backend\Template\DocumentTemplate;
use TYPO3\CMS\Backend\Utility\BackendUtility;
use TYPO3\CMS\Backend\Utility\IconUtility;
use TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
use TYPO3\CMS\Core\Database\DatabaseConnection;
use TYPO3\CMS\Core\Html\HtmlParser;
use TYPO3\CMS\Core\Html\RteHtmlParser;
use TYPO3\CMS\Core\Messaging\FlashMessage;
use TYPO3\CMS\Core\Messaging\FlashMessageQueue;
use TYPO3\CMS\Core\Messaging\FlashMessageService;
use TYPO3\CMS\Core\Resource\ProcessedFile;
use TYPO3\CMS\Core\Resource\ResourceFactory;
use TYPO3\CMS\Core\Utility\ArrayUtility;
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;
use TYPO3\CMS\Core\Utility\PathUtility;
use TYPO3\CMS\Lang\LanguageService;

/**
 * 'TCEforms' - Class for creating the backend editing forms.
 *
 * @author Kasper Skårhøj <kasperYYYY@typo3.com>
 * @coauthor René Fritz <r.fritz@colorcube.de>
 */
class FormEngine {

        /**
         * @todo Define visibility
         * @var array
         */
        public $palFieldArr = array();

        /**
         * @todo Define visibility
         * @var bool
         */
        public $disableWizards = FALSE;

        /**
         * @todo Define visibility
         * @var bool
         */
        public $isPalettedoc = FALSE;

        /**
         * @todo Define visibility
         * @var int
         */
        public $paletteMargin = 1;

        /**
         * @todo Define visibility
         * @var string
         */
        public $defStyle = '';

        /**
         * @todo Define visibility
         * @var array
         */
        public $cachedTSconfig = array();

        /**
         * @todo Define visibility
         * @var array
         */
        public $cachedTSconfig_fieldLevel = array();

        /**
         * @todo Define visibility
         * @var array
         */
        public $cachedLanguageFlag = array();

        /**
         * @todo Define visibility
         * @var array|NULL
         */
        public $cachedAdditionalPreviewLanguages = NULL;

        /**
         * Cache for the real PID of a record. The array key consists for a combined string "<table>:<uid>:<pid>".
         * The value is an array with two values: first is the real PID of a record, second is the PID value for TSconfig.
         *
         * @var array
         */
        protected $cache_getTSCpid = array();

        /**
         * @todo Define visibility
         * @var array
         */
        public $transformedRow = array();

        /**
         * @todo Define visibility
         * @var string
         */
        public $extJSCODE = '';

        /**
         * @todo Define visibility
         * @var array
         */
        public $printNeededJS = array();

        /**
         * @todo Define visibility
         * @var array
         */
        public $hiddenFieldAccum = array();

        /**
         * @todo Define visibility
         * @var string
         */
        public $TBE_EDITOR_fieldChanged_func = '';

        /**
         * @todo Define visibility
         * @var bool
         */
        public $loadMD5_JS = TRUE;

        /**
         * Array where records in the default language is stored. (processed by transferdata)
         *
         * @todo Define visibility
         * @var array
         */
        public $defaultLanguageData = array();

        /**
         * Array where records in the default language is stored (raw without any processing. used for making diff)
         *
         * @todo Define visibility
         * @var array
         */
        public $defaultLanguageData_diff = array();

        /**
         * @todo Define visibility
         * @var array
         */
        public $additionalPreviewLanguageData = array();

        // EXTERNAL, static
        /**
         * Set this to the 'backPath' pointing back to the typo3 admin directory
         * from the script where this form is displayed.
         *
         * @todo Define visibility
         * @var string
         */
        public $backPath = '';

        /**
         * Alternative return URL path (default is \TYPO3\CMS\Core\Utility\GeneralUtility::linkThisScript())
         *
         * @todo Define visibility
         * @var string
         */
        public $returnUrl = '';

        /**
         * Can be set to point to a field name in the form which will be set to '1' when the form
         * is submitted with a *save* button. This way the recipient script can determine that
         * the form was submitted for save and not "close" for example.
         *
         * @todo Define visibility
         * @var string
         */
        public $doSaveFieldName = '';

        /**
         * Can be set TRUE/FALSE to whether palettes (secondary options) are in the topframe or in form.
         * TRUE means they are NOT IN-form. So a collapsed palette is one, which is shown in the top frame, not in the page.
         *
         * @todo Define visibility
         * @var bool
         */
        public $palettesCollapsed = FALSE;

        /**
         * If set, the RTE is disabled (from form display, eg. by checkbox in the bottom of the page!)
         *
         * @todo Define visibility
         * @var bool
         */
        public $disableRTE = FALSE;

        /**
         * If FALSE, then all CSH will be disabled, regardless of settings in $this->edit_showFieldHelp
         *
         * @todo Define visibility
         * @var bool
         */
        public $globalShowHelp = TRUE;

        /**
         * If this evaluates to TRUE, the forms are rendering only localization relevant fields of the records.
         *
         * @todo Define visibility
         * @var string
         */
        public $localizationMode = '';

        /**
         * Overrule the field order set in TCA[types][showitem], eg for tt_content this value,
         * 'bodytext,image', would make first the 'bodytext' field, then the 'image' field (if set for display)...
         * and then the rest in the old order.
         *
         * @todo Define visibility
         * @var string
         */
        public $fieldOrder = '';

        /**
         * If set to FALSE, palettes will NEVER be rendered.
         *
         * @todo Define visibility
         * @var bool
         */
        public $doPrintPalette = TRUE;

        /**
         * Set to initialized clipboard object;
         * Then the element browser will offer a link to paste in records from clipboard.
         *
         * @var \TYPO3\CMS\Backend\Clipboard\Clipboard|NULL
         * @todo Define visibility
         */
        public $clipObj = NULL;

        /**
         * Enable click menu on reference icons.
         *
         * @todo Define visibility
         * @var bool
         */
        public $enableClickMenu = FALSE;

        /**
         * @todo Define visibility
         * @var bool
         */
        public $enableTabMenu = FALSE;

        /**
         * When enabled all fields are rendered non-editable
         *
         * @todo Define visibility
         * @var bool
         */
        public $renderReadonly = FALSE;

        /**
         * Form field width compensation: Factor of "size=12" to "style="width: 12*9.58px"
         * for form field widths of style-aware browsers
         *
         * @todo Define visibility
         * @var float
         */
        public $form_rowsToStylewidth = 9.58;

        /**
         * Value that gets added for style="width: ...px" for textareas compared to input fields.
         *
         * @var integer
         */
        protected $form_additionalTextareaStyleWidth = 23;

        /**
         * Form field width compensation: Compensation for large documents, doc-tab (editing)
         *
         * @todo Define visibility
         * @var float
         */
        public $form_largeComp = 1.33;

        /**
         * The number of chars expected per row when the height of a text area field is
         * automatically calculated based on the number of characters found in the field content.
         *
         * @todo Define visibility
         * @var int
         */
        public $charsPerRow = 40;

        /**
         * The maximum abstract value for textareas
         *
         * @todo Define visibility
         * @var int
         */
        public $maxTextareaWidth = 48;

        /**
         * The maximum abstract value for input fields
         * @todo Define visibility
         *
         * @var int
         */
        public $maxInputWidth = 48;

        /**
         * Default style for the selector boxes used for multiple items in "select" and "group" types.
         *
         * @todo Define visibility
         * @var string
         */
        public $defaultMultipleSelectorStyle = 'width:310px;';

        // INTERNAL, static
        /**
         * The string to prepend formfield names with.
         * @todo Define visibility
         *
         * @var string
         */
        public $prependFormFieldNames = 'data';

        /**
         * The string to prepend commands for tcemain::process_cmdmap with
         *
         * @todo Define visibility
         * @var string
         */
        public $prependCmdFieldNames = 'cmd';

        /**
         * The string to prepend FILE form field names with
         *
         * @todo Define visibility
         * @var string
         */
        public $prependFormFieldNames_file = 'data_files';

        /**
         * The string to prepend form field names that are active (not NULL)
         *
         * @var string
         */
        protected $prependFormFieldNamesActive = 'control[active]';

        /**
         * The name attribute of the form
         *
         * @todo Define visibility
         * @var string
         */
        public $formName = 'editform';

        /**
         * Whitelist that allows TCA field configuration to be overridden by TSconfig
         *
         * @todo Define visibility
         * @see overrideFieldConf()
         * @var array
         */
        public $allowOverrideMatrix = array();

        // INTERNAL, dynamic
        /**
         * Set by readPerms()  (caching)
         *
         * @todo Define visibility
         * @var string
         */
        public $perms_clause = '';

        /**
         * Set by readPerms()  (caching-flag)
         *
         * @todo Define visibility
         * @var bool
         */
        public $perms_clause_set = FALSE;

        /**
         * Used to indicate the mode of CSH (Context Sensitive Help),
         * whether it should be icons-only ('icon') or not at all (blank).
         *
         * @todo Define visibility
         * @var bool
         */
        public $edit_showFieldHelp = FALSE;

        /**
         * @var bool
         */
        public $edit_docModuleUpload = FALSE;

        /**
         * Loaded with info about the browser when class is instantiated
         *
         * @todo Define visibility
         * @var array
         */
        public $clientInfo = array();

        /**
         * TRUE, if RTE is possible for the current user (based on result from BE_USER->isRTE())
         *
         * @todo Define visibility
         * @var bool
         */
        public $RTEenabled = FALSE;

        /**
         * If $this->RTEenabled was FALSE, you can find the reasons listed in this array
         * which is filled with reasons why the RTE could not be loaded)
         * @todo Define visibility
         *
         * @var string
         */
        public $RTEenabled_notReasons = '';

        /**
         * Counter that is incremented before an RTE is created. Can be used for unique ids etc.
         *
         * @todo Define visibility
         * @var int
         */
        public $RTEcounter = 0;

        /**
         * Contains current color scheme
         *
         * @todo Define visibility
         * @var array
         */
        public $colorScheme = array();

        /**
         * Contains current class scheme
         *
         * @todo Define visibility
         * @var array
         */
        public $classScheme = array();

        /**
         * Contains the default color scheme
         *
         * @todo Define visibility
         * @var array
         */
        public $defColorScheme = array();

        /**
         * Contains the default class scheme
         *
         * @todo Define visibility
         * @var array
         */
        public $defClassScheme = array();

        /**
         * Contains field style values
         *
         * @todo Define visibility
         * @var array|NULL
         */
        public $fieldStyle = NULL;

        /**
         * Contains border style values
         *
         * @todo Define visibility
         * @var array|NULL
         */
        public $borderStyle = NULL;

        /**
         * An accumulation of messages from the class
         *
         * @todo Define visibility
         * @var array
         */
        public $commentMessages = array();

        // INTERNAL, templates
        /**
         * Total wrapping for the table rows
         *
         * @todo Define visibility
         * @var string
         */
        public $totalWrap = '<hr />|<hr />';

        /**
         * Field template
         *
         * @todo Define visibility
         * @var string
         */
        public $fieldTemplate = '<strong>###FIELD_NAME###</strong><br />###FIELD_ITEM###<hr />';

        /**
         * Template subpart for palette fields
         *
         * @var string
         */
        protected $paletteFieldTemplate = '';

        /**
         * Wrapping template code for a section
         *
         * @todo Define visibility
         * @var string
         */
        public $sectionWrap = '';

        /**
         * Template for palette headers
         *
         * @todo Define visibility
         * @var string
         */
        public $palFieldTemplateHeader = '';

        /**
         * Template for palettes
         *
         * @todo Define visibility
         * @var string
         */
        public $palFieldTemplate = '';

        // INTERNAL, working memory
        /**
         * Set to the fields NOT to display, if any
         *
         * @todo Define visibility
         * @var array|NULL
         */
        public $excludeElements = NULL;

        /**
         * During rendering of forms this will keep track of which palettes
         * has already been rendered (so they are not rendered twice by mistake)
         *
         * @todo Define visibility
         * @var array
         */
        public $palettesRendered = array();

        /**
         * This array of fields will be set as hidden-fields instead of rendered normally!
         * For instance palette fields edited in the top frame are set as hidden fields
         * since the main form has to submit the values.
         * The top frame actually just sets the value in the main form!
         *
         * @todo Define visibility
         * @var array
         */
        public $hiddenFieldListArr = array();

        /**
         * Used to register input-field names, which are required. (Done during rendering of the fields).
         * This information is then used later when the JavaScript is made.
         *
         * @todo Define visibility
         * @var array
         */
        public $requiredFields = array();

        /**
         * Used to register input-field names, which are required an have additional requirements.
         * (e.g. like a date/time must be positive integer)
         * The information of this array is merged with $this->requiredFields later.
         *
         * @todo Define visibility
         * @var array
         */
        public $requiredAdditional = array();

        /**
         * Used to register the min and max number of elements
         * for selector boxes where that apply (in the "group" type for instance)
         *
         * @todo Define visibility
         * @var array
         */
        public $requiredElements = array();

        /**
         * Used to determine where $requiredFields or $requiredElements are nested (in Tabs or IRRE)
         *
         * @todo Define visibility
         * @var array
         */
        public $requiredNested = array();

        /**
         * Keeps track of the rendering depth of nested records
         *
         * @todo Define visibility
         * @var int
         */
        public $renderDepth = 0;

        /**
         * Color scheme buffer
         *
         * @todo Define visibility
         * @var array
         */
        public $savedSchemes = array();

        /**
         * holds the path an element is nested in (e.g. required for RTEhtmlarea)
         * @todo Define visibility
         *
         * @var array
         */
        public $dynNestedStack = array();

        // Internal, registers for user defined functions etc.
        /**
         * Additional HTML code, printed before the form
         *
         * @todo Define visibility
         * @var array
         */
        public $additionalCode_pre = array();

        /**
         * Additional JavaScript, printed before the form
         *
         * @todo Define visibility
         * @var array
         */
        public $additionalJS_pre = array();

        /**
         * Additional JavaScript printed after the form
         *
         * @todo Define visibility
         * @var array
         */
        public $additionalJS_post = array();

        /**
         * Additional JavaScript executed on submit; If you set "OK" variable it will raise an error
         * about RTEs not being loaded and offer to block further submission.
         *
         * @todo Define visibility
         * @var array
         */
        public $additionalJS_submit = array();

        /**
         * Additional JavaScript executed when section element is deleted.
         * This is necessary, for example, to correctly clean up HTMLArea RTE (bug #8232)
         *
         * @todo Define visibility
         * @var array
         */
        public $additionalJS_delete = array();

        /**
         * @var \TYPO3\CMS\Backend\Form\Element\InlineElement
         * @todo Define visibility
         */
        public $inline;

        /**
         * Array containing hook class instances called once for a form
         *
         * @todo Define visibility
         * @var array
         */
        public $hookObjectsMainFields = array();

        /**
         * Array containing hook class instances called for each field
         *
         * @todo Define visibility
         * @var array
         */
        public $hookObjectsSingleField = array();

        /**
         * Rows getting inserted into the alt_doc headers (when called from alt_doc.php)
         *
         * @todo Define visibility
         * @var array
         */
        public $extraFormHeaders = array();

        /**
         * Form template, relative to typo3 directory
         *
         * @var string
         */
        public $templateFile = '';

        /**
         * @var integer
         */
        protected $multiSelectFilterCount = 0;

        /**
         * @var \TYPO3\CMS\Backend\Form\Element\SuggestElement
         */
        protected $suggest;

        /**
         * Constructor function, setting internal variables, loading the styles used.
         *
         * @todo Define visibility
         */
        public function __construct() {
                $this->clientInfo = GeneralUtility::clientInfo();
                $this->RTEenabled = $this->getBackendUserAuthentication()->isRTE();
                if (!$this->RTEenabled) {
                        $this->RTEenabled_notReasons = implode(LF, $this->getBackendUserAuthentication()->RTE_errors);
                        $this->commentMessages[] = 'RTE NOT ENABLED IN SYSTEM due to:' . LF . $this->RTEenabled_notReasons;
                }
                // Default color+class scheme
                $docTemplate = $this->getControllerDocumentTemplate();
                $this->defColorScheme = array(
                        $docTemplate->bgColor,
                        // Background for the field AND palette
                        GeneralUtility::modifyHTMLColorAll($docTemplate->bgColor, -20),
                        // Background for the field header
                        GeneralUtility::modifyHTMLColorAll($docTemplate->bgColor, -10),
                        // Background for the palette field header
                        'black',
                        // Field header font color
                        '#666666'
                );
                $this->defColorScheme = array();
                // Override / Setting defaults from TBE_STYLES array
                $this->resetSchemes();
                // Setting the current colorScheme to default.
                $this->defColorScheme = $this->colorScheme;
                $this->defClassScheme = $this->classScheme;
                // Define whitelist that allows TCA field configuration to be overridden by TSconfig, @see overrideFieldConf():
                $this->allowOverrideMatrix = array(
                        'input' => array('size', 'max', 'readOnly'),
                        'text' => array('cols', 'rows', 'wrap', 'readOnly'),
                        'check' => array('cols', 'showIfRTE', 'readOnly'),
                        'select' => array('size', 'autoSizeMax', 'maxitems', 'minitems', 'readOnly', 'treeConfig'),
                        'group' => array('size', 'autoSizeMax', 'max_size', 'show_thumbs', 'maxitems', 'minitems', 'disable_controls', 'readOnly'),
                        'inline' => array('appearance', 'behaviour', 'foreign_label', 'foreign_selector', 'foreign_unique', 'maxitems', 'minitems', 'size', 'autoSizeMax', 'symmetric_label', 'readOnly')
                );
                // Create instance of InlineElement only if this a non-IRRE-AJAX call:
                if (!isset($GLOBALS['ajaxID']) || strpos($GLOBALS['ajaxID'], 'TYPO3\\CMS\\Backend\\Form\\Element\\InlineElement::') !== 0) {
                        $this->inline = GeneralUtility::makeInstance('TYPO3\\CMS\\Backend\\Form\\Element\\InlineElement');
                }
                // Create instance of \TYPO3\CMS\Backend\Form\Element\SuggestElement only if this a non-Suggest-AJAX call:
                if (!isset($GLOBALS['ajaxID']) || strpos($GLOBALS['ajaxID'], 'TYPO3\\CMS\\Backend\\Form\\Element\\SuggestElement::') !== 0) {
                        $this->suggest = GeneralUtility::makeInstance('TYPO3\\CMS\\Backend\\Form\\Element\\SuggestElement');
                }
                // Prepare user defined objects (if any) for hooks which extend this function:
                $this->hookObjectsMainFields = array();
                if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tceforms.php']['getMainFieldsClass'])) {
                        foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tceforms.php']['getMainFieldsClass'] as $classRef) {
                                $this->hookObjectsMainFields[] = GeneralUtility::getUserObj($classRef);
                        }
                }
                $this->hookObjectsSingleField = array();
                if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tceforms.php']['getSingleFieldClass'])) {
                        foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tceforms.php']['getSingleFieldClass'] as $classRef) {
                                $this->hookObjectsSingleField[] = GeneralUtility::getUserObj($classRef);
                        }
                }
                $this->templateFile = 'sysext/backend/Resources/Private/Templates/FormEngine.html';
        }

        /**
         * Initialize various internal variables.
         *
         * @return void
         * @todo Define visibility
         */
        public function initDefaultBEmode() {
                $this->prependFormFieldNames = 'data';
                $this->formName = 'editform';
                $this->setNewBEDesign();
                $this->edit_showFieldHelp = (bool)$this->getBackendUserAuthentication()->uc['edit_showFieldHelp'];
                $this->edit_docModuleUpload = (bool)$this->getBackendUserAuthentication()->uc['edit_docModuleUpload'];
                $this->inline->init($this);
                $this->suggest->init($this);
        }

        /*******************************************************
         *
         * Rendering the forms, fields etc
         *
         *******************************************************/
        /**
         * Will return the TCEform element for just a single field from a record.
         * The field must be listed in the currently displayed fields (as found in [types][showitem]) for the record.
         * This also means that the $table/$row supplied must be complete so the list of fields to show can be found correctly
         *
         * @param string $table The table name
         * @param array $row The record from the table for which to render a field.
         * @param string $theFieldToReturn The field name to return the TCEform element for.
         * @return string HTML output
         * @see getMainFields()
         * @todo Define visibility
         */
        public function getSoloField($table, $row, $theFieldToReturn) {
                if ($GLOBALS['TCA'][$table]) {
                        $typeNum = $this->getRTypeNum($table, $row);
                        if ($GLOBALS['TCA'][$table]['types'][$typeNum]) {
                                $itemList = $GLOBALS['TCA'][$table]['types'][$typeNum]['showitem'];
                                if ($itemList) {
                                        $fields = GeneralUtility::trimExplode(',', $itemList, TRUE);
                                        $excludeElements = ($this->excludeElements = $this->getExcludeElements($table, $row, $typeNum));
                                        foreach ($fields as $fieldInfo) {
                                                $parts = explode(';', $fieldInfo);
                                                $theField = trim($parts[0]);
                                                if (!in_array($theField, $excludeElements) && (string)$theField === (string)$theFieldToReturn) {
                                                        if ($GLOBALS['TCA'][$table]['columns'][$theField]) {
                                                                $sField = $this->getSingleField($table, $theField, $row, $parts[1], 1, $parts[3], $parts[2]);
                                                                return $sField['ITEM'];
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        /**
         * Based on the $table and $row of content, this displays the complete TCEform for the record.
         * The input-$row is required to be preprocessed if necessary by eg.
         * the \TYPO3\CMS\Backend\Form\DataPreprocessor class. For instance the RTE content
         * should be transformed through this class first.
         *
         * @param string $table The table name
         * @param array $row The record from the table for which to render a field.
         * @param integer $depth Depth level
         * @param array $overruleTypesArray Overrule types array. Can be used to override the showitem etc. configuration for the TCA types of the table. Can contain all settings which are possible in the TCA 'types' section. See e.g. $TCA['tt_content']['types'].
         * @return string HTML output
         * @see getSoloField()
         * @todo Define visibility
         */
        public function getMainFields($table, array $row, $depth = 0, array $overruleTypesArray = array()) {
                $this->renderDepth = $depth;
                // Init vars:
                $out_array = array(array());
                $out_array_meta = array(
                        array(
                                'title' => $this->getLL('l_generalTab')
                        )
                );
                $out_pointer = 0;
                $out_sheet = 0;
                $this->palettesRendered = array();
                $this->palettesRendered[$this->renderDepth][$table] = array();
                // Hook: getMainFields_preProcess (requested by Thomas Hempel for use with the "dynaflex" extension)
                foreach ($this->hookObjectsMainFields as $hookObj) {
                        if (method_exists($hookObj, 'getMainFields_preProcess')) {
                                $hookObj->getMainFields_preProcess($table, $row, $this);
                        }
                }
                if ($GLOBALS['TCA'][$table]) {
                        // Get dividers2tabs setting from TCA of the current table:
                        $dividers2tabs = &$GLOBALS['TCA'][$table]['ctrl']['dividers2tabs'];
                        // Load the description content for the table.
                        if ($this->edit_showFieldHelp || $this->doLoadTableDescr($table)) {
                                $this->getLanguageService()->loadSingleTableDescription($table);
                        }
                        // Get the current "type" value for the record.
                        $typeNum = $this->getRTypeNum($table, $row);
                        // Find the list of fields to display:
                        if ($GLOBALS['TCA'][$table]['types'][$typeNum]) {
                                $itemList = $GLOBALS['TCA'][$table]['types'][$typeNum]['showitem'];
                                if (is_array($overruleTypesArray) && isset($overruleTypesArray[$typeNum]['showitem'])) {
                                        $itemList = $overruleTypesArray[$typeNum]['showitem'];
                                }
                                // If such a list existed...
                                if ($itemList) {
                                        // Explode the field list and possibly rearrange the order of the fields, if configured for
                                        $fields = GeneralUtility::trimExplode(',', $itemList, TRUE);
                                        if ($this->fieldOrder) {
                                                $fields = $this->rearrange($fields);
                                        }
                                        // Get excluded fields, added fiels and put it together:
                                        $excludeElements = ($this->excludeElements = $this->getExcludeElements($table, $row, $typeNum));
                                        $fields = $this->mergeFieldsWithAddedFields($fields, $this->getFieldsToAdd($table, $row, $typeNum), $table);
                                        // If TCEforms will render a tab menu in the next step, push the name to the tab stack:
                                        $tabIdentString = '';
                                        $tabIdentStringMD5 = '';
                                        if (strstr($itemList, '--div--') !== FALSE && $this->enableTabMenu && $dividers2tabs) {
                                                $tabIdentString = 'TCEforms:' . $table . ':' . $row['uid'];
                                                $tabIdentStringMD5 = $this->getDocumentTemplate()->getDynTabMenuId($tabIdentString);
                                                // Remember that were currently working on the general tab:
                                                if (isset($fields[0]) && strpos($fields[0], '--div--') !== 0) {
                                                        $this->pushToDynNestedStack('tab', $tabIdentStringMD5 . '-1');
                                                }
                                        }
                                        // Traverse the fields to render:
                                        $cc = 0;
                                        foreach ($fields as $fieldInfo) {
                                                // Exploding subparts of the field configuration:
                                                $parts = explode(';', $fieldInfo);
                                                // Getting the style information out:
                                                $color_style_parts = GeneralUtility::trimExplode('-', $parts[4]);
                                                if ($color_style_parts[0] !== '') {
                                                        $this->setColorScheme($GLOBALS['TBE_STYLES']['colorschemes'][(int)$color_style_parts[0]]);
                                                }
                                                if ($color_style_parts[1] !== '') {
                                                        $this->fieldStyle = $GLOBALS['TBE_STYLES']['styleschemes'][(int)$color_style_parts[1]];
                                                        if (!isset($this->fieldStyle)) {
                                                                $this->fieldStyle = $GLOBALS['TBE_STYLES']['styleschemes'][0];
                                                        }
                                                }
                                                if ($color_style_parts[2] !== '') {
                                                        $this->wrapBorder($out_array[$out_sheet], $out_pointer);
                                                        $this->borderStyle = $GLOBALS['TBE_STYLES']['borderschemes'][(int)$color_style_parts[2]];
                                                        if (!isset($this->borderStyle)) {
                                                                $this->borderStyle = $GLOBALS['TBE_STYLES']['borderschemes'][0];
                                                        }
                                                }
                                                // Render the field:
                                                $theField = $parts[0];
                                                if (!in_array($theField, $excludeElements)) {
                                                        if ($GLOBALS['TCA'][$table]['columns'][$theField]) {
                                                                $sFieldPal = '';
                                                                if ($parts[2] && !isset($this->palettesRendered[$this->renderDepth][$table][$parts[2]])) {
                                                                        $sFieldPal = $this->getPaletteFields($table, $row, $parts[2]);
                                                                        $this->palettesRendered[$this->renderDepth][$table][$parts[2]] = 1;
                                                                }
                                                                $sField = $this->getSingleField($table, $theField, $row, $parts[1], 0, $parts[3], $parts[2]);
                                                                if ($sField) {
                                                                        $sField .= $sFieldPal;
                                                                }
                                                                $out_array[$out_sheet][$out_pointer] .= $sField;
                                                        } elseif ($theField == '--div--') {
                                                                if ($cc > 0) {
                                                                        $out_array[$out_sheet][$out_pointer] .= $this->getDivider();
                                                                        if ($this->enableTabMenu && $dividers2tabs) {
                                                                                $this->wrapBorder($out_array[$out_sheet], $out_pointer);
                                                                                // Remove last tab entry from the dynNestedStack:
                                                                                $out_sheet++;
                                                                                // Remove the previous sheet from stack (if any):
                                                                                $this->popFromDynNestedStack('tab', $tabIdentStringMD5 . '-' . $out_sheet);
                                                                                // Remember on which sheet we're currently working:
                                                                                $this->pushToDynNestedStack('tab', $tabIdentStringMD5 . '-' . ($out_sheet + 1));
                                                                                $out_array[$out_sheet] = array();
                                                                                $out_array_meta[$out_sheet]['title'] = $this->sL($parts[1]);
                                                                                // Register newline for Tab
                                                                                $out_array_meta[$out_sheet]['newline'] = $parts[2] == 'newline';
                                                                        }
                                                                } else {
                                                                        // Setting alternative title for "General" tab if "--div--" is the very first element.
                                                                        $out_array_meta[$out_sheet]['title'] = $this->sL($parts[1]);
                                                                        // Only add the first tab to the dynNestedStack if there are more tabs:
                                                                        if ($tabIdentString && strpos($itemList, '--div--', strlen($fieldInfo))) {
                                                                                $this->pushToDynNestedStack('tab', $tabIdentStringMD5 . '-1');
                                                                        }
                                                                }
                                                        } elseif ($theField == '--palette--') {
                                                                if ($parts[2] && !isset($this->palettesRendered[$this->renderDepth][$table][$parts[2]])) {
                                                                        // Render a 'header' if not collapsed
                                                                        if ($GLOBALS['TCA'][$table]['palettes'][$parts[2]]['canNotCollapse'] && $parts[1]) {
                                                                                $out_array[$out_sheet][$out_pointer] .= $this->getPaletteFields($table, $row, $parts[2], $this->sL($parts[1]));
                                                                        } else {
                                                                                $out_array[$out_sheet][$out_pointer] .= $this->getPaletteFields($table, $row, $parts[2], '', '', $this->sL($parts[1]));
                                                                        }
                                                                        $this->palettesRendered[$this->renderDepth][$table][$parts[2]] = 1;
                                                                }
                                                        }
                                                }
                                                $cc++;
                                        }
                                }
                        }
                }
                // Hook: getMainFields_postProcess (requested by Thomas Hempel for use with the "dynaflex" extension)
                foreach ($this->hookObjectsMainFields as $hookObj) {
                        if (method_exists($hookObj, 'getMainFields_postProcess')) {
                                $hookObj->getMainFields_postProcess($table, $row, $this);
                        }
                }
                // Wrapping a border around it all:
                $this->wrapBorder($out_array[$out_sheet], $out_pointer);
                // Resetting styles:
                $this->resetSchemes();
                // Rendering Main palettes, if any
                $mParr = GeneralUtility::trimExplode(',', $GLOBALS['TCA'][$table]['ctrl']['mainpalette']);
                $i = 0;
                if (count($mParr)) {
                        foreach ($mParr as $mP) {
                                if (!isset($this->palettesRendered[$this->renderDepth][$table][$mP])) {
                                        $temp_palettesCollapsed = $this->palettesCollapsed;
                                        $this->palettesCollapsed = FALSE;
                                        $label = $i == 0 ? $this->getLL('l_generalOptions') : $this->getLL('l_generalOptions_more');
                                        $out_array[$out_sheet][$out_pointer] .= $this->getPaletteFields($table, $row, $mP, $label);
                                        $this->palettesCollapsed = $temp_palettesCollapsed;
                                        $this->palettesRendered[$this->renderDepth][$table][$mP] = 1;
                                }
                                $this->wrapBorder($out_array[$out_sheet], $out_pointer);
                                $i++;
                                if ($this->renderDepth) {
                                        $this->renderDepth--;
                                }
                        }
                }
                // Return the imploded $out_array:
                // There were --div-- dividers around...
                if ($out_sheet > 0) {
                        // Create parts array for the tab menu:
                        $parts = array();
                        foreach ($out_array as $idx => $sheetContent) {
                                $content = implode('', $sheetContent);
                                if ($content) {
                                        // Wrap content (row) with table-tag, otherwise tab/sheet will be disabled (see getdynTabMenu() )
                                        $content = '<table border="0" cellspacing="0" cellpadding="0" width="100%">' . $content . '</table>';
                                }
                                $parts[$idx] = array(
                                        'label' => $out_array_meta[$idx]['title'],
                                        'content' => $content,
                                        'newline' => $out_array_meta[$idx]['newline']
                                );
                        }
                        if (count($parts) > 1) {
                                // Unset the current level of tab menus:
                                $this->popFromDynNestedStack('tab', $tabIdentStringMD5 . '-' . ($out_sheet + 1));
                                $dividersToTabsBehaviour = isset($GLOBALS['TCA'][$table]['ctrl']['dividers2tabs']) ? $GLOBALS['TCA'][$table]['ctrl']['dividers2tabs'] : 1;
                                $output = $this->getDynTabMenu($parts, $tabIdentString, $dividersToTabsBehaviour);
                        } else {
                                // If there is only one tab/part there is no need to wrap it into the dynTab code
                                $output = isset($parts[0]) ? trim($parts[0]['content']) : '';
                        }
                        $output = '
                                <tr>
                                        <td colspan="2">
                                        ' . $output . '
                                        </td>
                                </tr>';
                } else {
                        // Only one tab, so just implode and wrap the background image (= tab container) around:
                        $output = implode('', $out_array[$out_sheet]);
                        $output = '<div class="typo3-dyntabmenu-divs">' . $output . '</div>';
                }

                return $output;
        }

        /**
         * Will return the TCEform elements for a pre-defined list of fields.
         * Notice that this will STILL use the configuration found in the list [types][showitem] for those fields which are found there. So ideally the list of fields given as argument to this function should also be in the current [types][showitem] list of the record.
         * Used for displaying forms for the frontend edit icons for instance.
         *
         * @param string $table The table name
         * @param array $row The record array.
         * @param string $list Commalist of fields from the table. These will be shown in the specified order in a form.
         * @return string TCEform elements in a string.
         * @todo Define visibility
         */
        public function getListedFields($table, $row, $list) {
                if ($this->edit_showFieldHelp || $this->doLoadTableDescr($table)) {
                        $this->getLanguageService()->loadSingleTableDescription($table);
                }
                $out = '';
                $types_fieldConfig = BackendUtility::getTCAtypes($table, $row, 1);
                $editFieldList = array_unique(GeneralUtility::trimExplode(',', $list, TRUE));
                foreach ($editFieldList as $theFieldC) {
                        list($theField, $palFields) = preg_split('/\\[|\\]/', $theFieldC);
                        $theField = trim($theField);
                        $palFields = trim($palFields);
                        if ($GLOBALS['TCA'][$table]['columns'][$theField]) {
                                $parts = GeneralUtility::trimExplode(';', $types_fieldConfig[$theField]['origString']);
                                // Don't sent palette pointer - there are no options anyways for a field-list.
                                $sField = $this->getSingleField($table, $theField, $row, $parts[1], 0, $parts[3], 0);
                                $out .= $sField;
                        } elseif ($theField == '--div--') {
                                $out .= $this->getDivider();
                        }
                        if ($palFields) {
                                $out .= $this->getPaletteFields($table, $row, '', '', implode(',', GeneralUtility::trimExplode('|', $palFields, TRUE)));
                        }
                }
                return $out;
        }

        /**
         * Creates a palette (collection of secondary options).
         *
         * @param string $table The table name
         * @param array $row The row array
         * @param string $palette The palette number/pointer
         * @param string $header Header string for the palette (used when in-form). If not set, no header item is made.
         * @param string $itemList Optional alternative list of fields for the palette
         * @param string $collapsedHeader Optional Link text for activating a palette (when palettes does not have another form element to belong to).
         * @return string HTML code.
         * @todo Define visibility
         */
        public function getPaletteFields($table, $row, $palette, $header = '', $itemList = '', $collapsedHeader = NULL) {
                if (!$this->doPrintPalette) {
                        return '';
                }
                $out = '';
                $parts = $this->loadPaletteElements($table, $row, $palette, $itemList);
                // Put palette together if there are fields in it:
                if (count($parts)) {
                        $realFields = 0;
                        foreach ($parts as $part) {
                                if ($part['NAME'] !== '--linebreak--') {
                                        $realFields++;
                                }
                        }
                        if ($realFields > 0) {
                                if ($header) {
                                        $out .= $this->intoTemplate(array('HEADER' => htmlspecialchars($header)), $this->palFieldTemplateHeader);
                                }
                                $collapsed = $this->isPalettesCollapsed($table, $palette);
                                // Check if the palette is a hidden palette
                                $isHiddenPalette = !empty($GLOBALS['TCA'][$table]['palettes'][$palette]['isHiddenPalette']);
                                $thePalIcon = '';
                                if ($collapsed && $collapsedHeader !== NULL && !$isHiddenPalette) {
                                        list($thePalIcon, ) = $this->wrapOpenPalette(IconUtility::getSpriteIcon('actions-system-options-view', array('title' => htmlspecialchars($this->getLL('l_moreOptions')))), $table, $row, $palette, 1);
                                        $thePalIcon = '<span style="margin-left: 20px;">' . $thePalIcon . $collapsedHeader . '</span>';
                                }
                                $paletteHtml = $this->wrapPaletteField($this->printPalette($parts), $table, $row, $palette, $collapsed);
                                $out .= $this->intoTemplate(array('PALETTE' => $thePalIcon . $paletteHtml), $this->palFieldTemplate);
                        }
                }
                return $out;
        }

        /**
         * Returns the form HTML code for a database table field.
         *
         * @param string $table The table name
         * @param string $field The field name
         * @param array $row The record to edit from the database table.
         * @param string $altName Alternative field name label to show.
         * @param boolean $palette Set this if the field is on a palette (in top frame), otherwise not. (if set, field will render as a hidden field).
         * @param string $extra The "extra" options from "Part 4" of the field configurations found in the "types" "showitem" list. Typically parsed by $this->getSpecConfFromString() in order to get the options as an associative array.
         * @param integer $pal The palette pointer.
         * @return mixed String (normal) or array (palettes)
         * @todo Define visibility
         */
        public function getSingleField($table, $field, $row, $altName = '', $palette = FALSE, $extra = '', $pal = 0) {
                // Hook: getSingleField_preProcess
                foreach ($this->hookObjectsSingleField as $hookObj) {
                        if (method_exists($hookObj, 'getSingleField_preProcess')) {
                                $hookObj->getSingleField_preProcess($table, $field, $row, $altName, $palette, $extra, $pal, $this);
                        }
                }
                $out = '';
                $PA = array();
                $PA['altName'] = $altName;
                $PA['palette'] = $palette;
                $PA['extra'] = $extra;
                $PA['pal'] = $pal;
                // Get the TCA configuration for the current field:
                $PA['fieldConf'] = $GLOBALS['TCA'][$table]['columns'][$field];
                $PA['fieldConf']['config']['form_type'] = $PA['fieldConf']['config']['form_type'] ?: $PA['fieldConf']['config']['type'];

                // Using "form_type" locally in this script
                $skipThisField = $this->inline->skipField($table, $field, $row, $PA['fieldConf']['config']);

                // Evaluate display condition
                $displayConditionResult = TRUE;
                if (is_array($PA['fieldConf']) && $PA['fieldConf']['displayCond'] && is_array($row)) {
                        /** @var $elementConditionMatcher \TYPO3\CMS\Backend\Form\ElementConditionMatcher */
                        $elementConditionMatcher = GeneralUtility::makeInstance('TYPO3\\CMS\\Backend\\Form\\ElementConditionMatcher');
                        $displayConditionResult = $elementConditionMatcher->match($PA['fieldConf']['displayCond'], $row);
                }
                // Check if this field is configured and editable (according to excludefields + other configuration)
                if (
                        is_array($PA['fieldConf'])
                        && !$skipThisField
                        && (!$PA['fieldConf']['exclude'] || $this->getBackendUserAuthentication()->check('non_exclude_fields', $table . ':' . $field))
                        && $PA['fieldConf']['config']['form_type'] != 'passthrough'
                        && ($this->RTEenabled || !$PA['fieldConf']['config']['showIfRTE'])
                        && $displayConditionResult
                        && (!$GLOBALS['TCA'][$table]['ctrl']['languageField'] || $PA['fieldConf']['l10n_display'] || ($PA['fieldConf']['l10n_mode'] !== 'exclude') || $row[$GLOBALS['TCA'][$table]['ctrl']['languageField']] <= 0)
                        && (!$GLOBALS['TCA'][$table]['ctrl']['languageField'] || !$this->localizationMode || $this->localizationMode === $PA['fieldConf']['l10n_cat'])
                ) {
                        // Fetching the TSconfig for the current table/field. This includes the $row which means that
                        $PA['fieldTSConfig'] = $this->setTSconfig($table, $row, $field);
                        // If the field is NOT disabled from TSconfig (which it could have been) then render it
                        if (!$PA['fieldTSConfig']['disabled']) {
                                // Override fieldConf by fieldTSconfig:
                                $PA['fieldConf']['config'] = $this->overrideFieldConf($PA['fieldConf']['config'], $PA['fieldTSConfig']);
                                // Init variables:
                                $PA['itemFormElName'] = $this->prependFormFieldNames . '[' . $table . '][' . $row['uid'] . '][' . $field . ']';
                                // Form field name, in case of file uploads
                                $PA['itemFormElName_file'] = $this->prependFormFieldNames_file . '[' . $table . '][' . $row['uid'] . '][' . $field . ']';
                                // Form field name, to activate elements
                                // If the "eval" list contains "null", elements can be deactivated which results in storing NULL to database
                                $PA['itemFormElNameActive'] = $this->prependFormFieldNamesActive . '[' . $table . '][' . $row['uid'] . '][' . $field . ']';
                                // The value to show in the form field.
                                $PA['itemFormElValue'] = $row[$field];
                                $PA['itemFormElID'] = $this->prependFormFieldNames . '_' . $table . '_' . $row['uid'] . '_' . $field;
                                // Set field to read-only if configured for translated records to show default language content as readonly
                                if ($PA['fieldConf']['l10n_display'] && GeneralUtility::inList($PA['fieldConf']['l10n_display'], 'defaultAsReadonly') && $row[$GLOBALS['TCA'][$table]['ctrl']['languageField']] > 0) {
                                        $PA['fieldConf']['config']['readOnly'] = TRUE;
                                        $PA['itemFormElValue'] = $this->defaultLanguageData[$table . ':' . $row['uid']][$field];
                                }
                                if (strpos($GLOBALS['TCA'][$table]['ctrl']['type'], ':') === FALSE) {
                                        $typeField = $GLOBALS['TCA'][$table]['ctrl']['type'];
                                } else {
                                        $typeField = substr($GLOBALS['TCA'][$table]['ctrl']['type'], 0, strpos($GLOBALS['TCA'][$table]['ctrl']['type'], ':'));
                                }
                                // Create a JavaScript code line which will ask the user to save/update the form due to changing the element. This is used for eg. "type" fields and others configured with "requestUpdate"
                                if (
                                        !empty($GLOBALS['TCA'][$table]['ctrl']['type'])
                                        && $field === $typeField
                                        || !empty($GLOBALS['TCA'][$table]['ctrl']['requestUpdate'])
                                        && GeneralUtility::inList(str_replace(' ', '', $GLOBALS['TCA'][$table]['ctrl']['requestUpdate']), $field)
                                ) {
                                        if ($this->getBackendUserAuthentication()->jsConfirmation(1)) {
                                                $alertMsgOnChange = 'if (confirm(TBE_EDITOR.labels.onChangeAlert) && TBE_EDITOR.checkSubmit(-1)){ TBE_EDITOR.submitForm() };';
                                        } else {
                                                $alertMsgOnChange = 'if (TBE_EDITOR.checkSubmit(-1)){ TBE_EDITOR.submitForm() };';
                                        }
                                } else {
                                        $alertMsgOnChange = '';
                                }
                                // Render as a hidden field?
                                if (in_array($field, $this->hiddenFieldListArr)) {
                                        $this->hiddenFieldAccum[] = '<input type="hidden" name="' . $PA['itemFormElName'] . '" value="' . htmlspecialchars($PA['itemFormElValue']) . '" />';
                                } else {
                                        // Render as a normal field:
                                        // If the field is NOT a palette field, then we might create an icon which links to a palette for the field, if one exists.
                                        if (!$PA['palette']) {
                                                $paletteFields = $this->loadPaletteElements($table, $row, $PA['pal']);
                                                if ($PA['pal'] && $this->isPalettesCollapsed($table, $PA['pal']) && count($paletteFields)) {
                                                        list($thePalIcon, $palJSfunc) = $this->wrapOpenPalette(IconUtility::getSpriteIcon('actions-system-options-view', array('title' => htmlspecialchars($this->getLL('l_moreOptions')))), $table, $row, $PA['pal'], 1);
                                                } else {
                                                        $thePalIcon = '';
                                                        $palJSfunc = '';
                                                }
                                        }
                                        // onFocus attribute to add to the field:
                                        $PA['onFocus'] = $palJSfunc && !$this->getBackendUserAuthentication()->uc['dontShowPalettesOnFocusInAB'] ? ' onfocus="' . htmlspecialchars($palJSfunc) . '"' : '';
                                        $PA['label'] = $PA['altName'] ?: $PA['fieldConf']['label'];
                                        $PA['label'] = $PA['fieldTSConfig']['label'] ?: $PA['label'];
                                        $PA['label'] = $PA['fieldTSConfig']['label.'][$this->getLanguageService()->lang] ?: $PA['label'];
                                        $PA['label'] = $this->sL($PA['label']);
                                        // JavaScript code for event handlers:
                                        $PA['fieldChangeFunc'] = array();
                                        $PA['fieldChangeFunc']['TBE_EDITOR_fieldChanged'] = 'TBE_EDITOR.fieldChanged(\'' . $table . '\',\'' . $row['uid'] . '\',\'' . $field . '\',\'' . $PA['itemFormElName'] . '\');';
                                        $PA['fieldChangeFunc']['alert'] = $alertMsgOnChange;
                                        // If this is the child of an inline type and it is the field creating the label
                                        if ($this->inline->isInlineChildAndLabelField($table, $field)) {
                                                $inlineObjectId = implode(InlineElement::Structure_Separator, array(
                                                        $this->inline->inlineNames['object'],
                                                        $table,
                                                        $row['uid']
                                                ));
                                                $PA['fieldChangeFunc']['inline'] = 'inline.handleChangedField(\'' . $PA['itemFormElName'] . '\',\'' . $inlineObjectId . '\');';
                                        }
                                        // Based on the type of the item, call a render function:
                                        $item = $this->getSingleField_SW($table, $field, $row, $PA);
                                        // Add language + diff
                                        if ($PA['fieldConf']['l10n_display'] && (GeneralUtility::inList($PA['fieldConf']['l10n_display'], 'hideDiff') || GeneralUtility::inList($PA['fieldConf']['l10n_display'], 'defaultAsReadonly'))) {
                                                $renderLanguageDiff = FALSE;
                                        } else {
                                                $renderLanguageDiff = TRUE;
                                        }
                                        if ($renderLanguageDiff) {
                                                $item = $this->renderDefaultLanguageContent($table, $field, $row, $item);
                                                $item = $this->renderDefaultLanguageDiff($table, $field, $row, $item);
                                        }
                                        // If the record has been saved and the "linkTitleToSelf" is set, we make the field name into a link, which will load ONLY this field in alt_doc.php
                                        $label = htmlspecialchars($PA['label'], ENT_COMPAT, 'UTF-8', FALSE);
                                        if (MathUtility::canBeInterpretedAsInteger($row['uid']) && $PA['fieldTSConfig']['linkTitleToSelf'] && !GeneralUtility::_GP('columnsOnly')) {
                                                $lTTS_url = $this->backPath . 'alt_doc.php?edit[' . $table . '][' . $row['uid'] . ']=edit&columnsOnly=' . $field . '&returnUrl=' . rawurlencode($this->thisReturnUrl());
                                                $label = '<a href="' . htmlspecialchars($lTTS_url) . '">' . $label . '</a>';
                                        }

                                        if (isset($PA['fieldConf']['config']['mode']) && $PA['fieldConf']['config']['mode'] == 'useOrOverridePlaceholder') {
                                                $placeholder = $this->getPlaceholderValue($table, $field, $PA['fieldConf']['config'], $row);
                                                $onChange = 'typo3form.fieldTogglePlaceholder(' . GeneralUtility::quoteJSvalue($PA['itemFormElName']) . ', !this.checked)';
                                                $checked = $PA['itemFormElValue'] === NULL ? '' : ' checked="checked"';

                                                $this->additionalJS_post[] = 'typo3form.fieldTogglePlaceholder('
                                                        . GeneralUtility::quoteJSvalue($PA['itemFormElName']) . ', ' . ($checked ? 'false' : 'true') . ');';

                                                $item = '<div class="t3-form-field-placeholder-override">'
                                                . '<span class="t3-tceforms-placeholder-override-checkbox">' .
                                                        '<input type="hidden" name="' . htmlspecialchars($PA['itemFormElNameActive']) . '" value="0" />' .
                                                        '<input type="checkbox" name="' . htmlspecialchars($PA['itemFormElNameActive']) . '" value="1" id="tce-forms-textfield-use-override-' . $field . '-' . $row['uid'] . '" onchange="' . htmlspecialchars($onChange) . '"' . $checked . ' />' .
                                                        '<label for="tce-forms-textfield-use-override-' . $field . '-' . $row['uid'] . '">' .
                                                        sprintf($this->getLanguageService()->sL('LLL:EXT:lang/locallang_core.xlf:labels.placeholder.override'),
                                                        BackendUtility::getRecordTitlePrep($placeholder, 20)) . '</label>' .
                                                '</span>'
                                                . '<div class="t3-form-placeholder-placeholder">' . $this->getSingleField_typeNone_render(
                                                        $PA['fieldConf']['config'], GeneralUtility::fixed_lgd_cs($placeholder, 30)
                                                ) . '</div>'
                                                . '<div class="t3-form-placeholder-formfield">' . $item . '</div>'
                                                . '</div>';
                                        }

                                        // Wrap the label with help text
                                        $PA['label'] = ($label = BackendUtility::wrapInHelp($table, $field, $label));
                                        // Create output value:
                                        if ($PA['fieldConf']['config']['form_type'] == 'user' && $PA['fieldConf']['config']['noTableWrapping']) {
                                                $out = $item;
                                        } elseif ($PA['palette']) {
                                                // Array:
                                                $out = array(
                                                        'NAME' => $label,
                                                        'ID' => $row['uid'],
                                                        'FIELD' => $field,
                                                        'TABLE' => $table,
                                                        'ITEM' => $item,
                                                        'ITEM_DISABLED' => ($this->isDisabledNullValueField($table, $field, $row, $PA) ? ' disabled' : ''),
                                                        'ITEM_NULLVALUE' => $this->renderNullValueWidget($table, $field, $row, $PA),
                                                );
                                                $out = $this->addUserTemplateMarkers($out, $table, $field, $row, $PA);
                                        } else {
                                                // String:
                                                $out = array(
                                                        'NAME' => $label,
                                                        'ITEM' => $item,
                                                        'TABLE' => $table,
                                                        'ID' => $row['uid'],
                                                        'PAL_LINK_ICON' => $thePalIcon,
                                                        'FIELD' => $field,
                                                        'ITEM_DISABLED' => ($this->isDisabledNullValueField($table, $field, $row, $PA) ? ' disabled' : ''),
                                                        'ITEM_NULLVALUE' => $this->renderNullValueWidget($table, $field, $row, $PA),
                                                );
                                                $out = $this->addUserTemplateMarkers($out, $table, $field, $row, $PA);
                                                // String:
                                                $out = $this->intoTemplate($out);
                                        }
                                }
                        } else {
                                $this->commentMessages[] = $this->prependFormFieldNames . '[' . $table . '][' . $row['uid'] . '][' . $field . ']: Disabled by TSconfig';
                        }
                }
                // Hook: getSingleField_postProcess
                foreach ($this->hookObjectsSingleField as $hookObj) {
                        if (method_exists($hookObj, 'getSingleField_postProcess')) {
                                $hookObj->getSingleField_postProcess($table, $field, $row, $out, $PA, $this);
                        }
                }
                // Return value (string or array)
                return $out;
        }

        /**
         * Rendering a single item for the form
         *
         * @param string $table Table name of record
         * @param string $field Fieldname to render
         * @param array $row The record
         * @param array $PA Parameters array containing a lot of stuff. Value by Reference!
         * @return string Returns the item as HTML code to insert
         * @access private
         * @see getSingleField(), getSingleField_typeFlex_draw()
         * @todo Define visibility
         */
        public function getSingleField_SW($table, $field, $row, &$PA) {
                $PA['fieldConf']['config']['form_type'] = $PA['fieldConf']['config']['form_type'] ?: $PA['fieldConf']['config']['type'];
                // Using "form_type" locally in this script
                // Hook: getSingleField_beforeRender
                foreach ($this->hookObjectsSingleField as $hookObject) {
                        if (method_exists($hookObject, 'getSingleField_beforeRender')) {
                                $hookObject->getSingleField_beforeRender($table, $field, $row, $PA);
                        }
                }
                switch ($PA['fieldConf']['config']['form_type']) {
                        case 'input':
                                $item = $this->getSingleField_typeInput($table, $field, $row, $PA);
                                break;
                        case 'text':
                                $item = $this->getSingleField_typeText($table, $field, $row, $PA);
                                break;
                        case 'check':
                                $item = $this->getSingleField_typeCheck($table, $field, $row, $PA);
                                break;
                        case 'radio':
                                $item = $this->getSingleField_typeRadio($table, $field, $row, $PA);
                                break;
                        case 'select':
                                $item = $this->getSingleField_typeSelect($table, $field, $row, $PA);
                                break;
                        case 'group':
                                $item = $this->getSingleField_typeGroup($table, $field, $row, $PA);
                                break;
                        case 'inline':
                                $item = $this->inline->getSingleField_typeInline($table, $field, $row, $PA);
                                break;
                        case 'none':
                                $item = $this->getSingleField_typeNone($table, $field, $row, $PA);
                                break;
                        case 'user':
                                $item = $this->getSingleField_typeUser($table, $field, $row, $PA);
                                break;
                        case 'flex':
                                $item = $this->getSingleField_typeFlex($table, $field, $row, $PA);
                                break;
                        default:
                                $item = $this->getSingleField_typeUnknown($table, $field, $row, $PA);
                }
                return $item;
        }

        /**********************************************************
         *
         * Rendering of each TCEform field type
         *
         ************************************************************/
        /**
         * Generation of TCEform elements of the type "input"
         * This will render a single-line input form field, possibly with various control/validation features
         *
         * @param string $table The table name of the record
         * @param string $field The field name which this element is supposed to edit
         * @param array $row The record data array where the value(s) for the field can be found
         * @param array $PA An array with additional configuration options.
         * @return string The HTML code for the TCEform field
         * @todo Define visibility
         */
        public function getSingleField_typeInput($table, $field, $row, &$PA) {
                $config = $PA['fieldConf']['config'];
                $specConf = $this->getSpecConfFromString($PA['extra'], $PA['fieldConf']['defaultExtras']);
                $size = MathUtility::forceIntegerInRange($config['size'] ? $config['size'] : 30, 5, $this->maxInputWidth);
                $evalList = GeneralUtility::trimExplode(',', $config['eval'], TRUE);
                $classAndStyleAttributes = $this->formWidthAsArray($size);
                $fieldAppendix = '';
                $item = '';
                $cssClasses = array($classAndStyleAttributes['class']);
                $cssStyle = $classAndStyleAttributes['style'];
                if (!isset($config['checkbox'])) {
                        $config['checkbox'] = '0';
                        $checkboxIsset = FALSE;
                } else {
                        $checkboxIsset = TRUE;
                }
                if (in_array('date', $evalList) || in_array('datetime', $evalList)) {
                        if (in_array('datetime', $evalList)) {
                                $class = 'datetime';
                        } else {
                                $class = 'date';
                        }
                        $dateRange = '';
                        if (isset($config['range']['lower'])) {
                                $dateRange .= ' lower-' . (int)$config['range']['lower'];
                        }
                        if (isset($config['range']['upper'])) {
                                $dateRange .= ' upper-' . (int)$config['range']['upper'];
                        }
                        $inputId = uniqid('tceforms-' . $class . 'field-');
                        $cssClasses[] = 'tceforms-textfield tceforms-' . $class . 'field' . $dateRange;
                        $fieldAppendix = IconUtility::getSpriteIcon('actions-edit-pick-date', array(
                                'style' => 'cursor:pointer;',
                                'id' => 'picker-' . $inputId
                        ));
                } elseif (in_array('timesec', $evalList)) {
                        $inputId = uniqid('tceforms-timesecfield-');
                        $cssClasses[] = 'tceforms-textfield tceforms-timesecfield';
                } elseif (in_array('year', $evalList)) {
                        $inputId = uniqid('tceforms-yearfield-');
                        $cssClasses[] = 'tceforms-textfield tceforms-yearfield';
                } elseif (in_array('time', $evalList)) {
                        $inputId = uniqid('tceforms-timefield-');
                        $cssClasses[] = 'tceforms-textfield tceforms-timefield';
                } elseif (in_array('int', $evalList)) {
                        $inputId = uniqid('tceforms-intfield-');
                        $cssClasses[] = 'tceforms-textfield tceforms-intfield';
                } elseif (in_array('double2', $evalList)) {
                        $inputId = uniqid('tceforms-double2field-');
                        $cssClasses[] = 'tceforms-textfield tceforms-double2field';
                } else {
                        $inputId = uniqid('tceforms-textfield-');
                        $cssClasses[] = 'tceforms-textfield';
                        if ($checkboxIsset === FALSE) {
                                $config['checkbox'] = '';
                        }
                }
                if (isset($config['wizards']['link'])) {
                        $inputId = uniqid('tceforms-linkfield-');
                        $cssClasses[] = 'tceforms-textfield tceforms-linkfield';
                } elseif (isset($config['wizards']['color'])) {
                        $inputId = uniqid('tceforms-colorfield-');
                        $cssClasses[] = 'tceforms-textfield tceforms-colorfield';
                }
                if ($this->renderReadonly || $config['readOnly']) {
                        $itemFormElValue = $PA['itemFormElValue'];
                        if (in_array('date', $evalList)) {
                                $config['format'] = 'date';
                        } elseif (in_array('datetime', $evalList)) {
                                $config['format'] = 'datetime';
                        } elseif (in_array('time', $evalList)) {
                                $config['format'] = 'time';
                        }
                        if (in_array('password', $evalList)) {
                                $itemFormElValue = $itemFormElValue ? '*********' : '';
                        }
                        return $this->getSingleField_typeNone_render($config, $itemFormElValue);
                }
                foreach ($evalList as $func) {
                        switch ($func) {
                                case 'required':
                                        $this->registerRequiredProperty('field', $table . '_' . $row['uid'] . '_' . $field, $PA['itemFormElName']);
                                        // Mark this field for date/time disposal:
                                        if (array_intersect($evalList, array('date', 'datetime', 'time'))) {
                                                $this->requiredAdditional[$PA['itemFormElName']]['isPositiveNumber'] = TRUE;
                                        }
                                        break;
                                default:
                                        // Pair hook to the one in \TYPO3\CMS\Core\DataHandling\DataHandler::checkValue_input_Eval()
                                        $evalObj = GeneralUtility::getUserObj($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tce']['formevals'][$func] . ':&' . $func);
                                        if (is_object($evalObj) && method_exists($evalObj, 'deevaluateFieldValue')) {
                                                $_params = array(
                                                        'value' => $PA['itemFormElValue']
                                                );
                                                $PA['itemFormElValue'] = $evalObj->deevaluateFieldValue($_params);
                                        }
                        }
                }
                $paramsList = '\'' . $PA['itemFormElName'] . '\',\'' . implode(',', $evalList) . '\',\'' . trim($config['is_in']) . '\',' . (isset($config['checkbox']) ? 1 : 0) . ',\'' . $config['checkbox'] . '\'';
                if (in_array('date', $evalList) || in_array('datetime', $evalList)) {
                        $item .= '<span class="t3-tceforms-input-wrapper-datetime" onmouseOver="if (document.getElementById(\'' . $inputId . '\').value) {this.className=\'t3-tceforms-input-wrapper-datetime-hover\';} else {this.className=\'t3-tceforms-input-wrapper-datetime\';};" onmouseOut="this.className=\'t3-tceforms-input-wrapper-datetime\';">';
                        // Add server timezone offset to UTC to our stored date
                        if ($PA['itemFormElValue'] > 0) {
                                $PA['itemFormElValue'] += date('Z', $PA['itemFormElValue']);
                        }
                } else {
                        $item .= '<span class="t3-tceforms-input-wrapper" onmouseOver="if (document.getElementById(\'' . $inputId . '\').value) {this.className=\'t3-tceforms-input-wrapper-hover\';} else {this.className=\'t3-tceforms-input-wrapper\';};" onmouseOut="this.className=\'t3-tceforms-input-wrapper\';">';
                }
                $PA['fieldChangeFunc'] = array_merge(array('typo3form.fieldGet' => 'typo3form.fieldGet(' . $paramsList . ');'), $PA['fieldChangeFunc']);
                // Old function "checkbox" now the option to set the date / remove the date
                if (isset($config['checkbox'])) {
                        $item .= IconUtility::getSpriteIcon('actions-input-clear', array('tag' => 'a', 'class' => 't3-tceforms-input-clearer', 'onclick' => 'document.getElementById(\'' . $inputId . '\').value=\'\';document.getElementById(\'' . $inputId . '\').focus();' . implode('', $PA['fieldChangeFunc'])));
                }
                $mLgd = $config['max'] ?: 256;
                $iOnChange = implode('', $PA['fieldChangeFunc']);
                $cssClasses[] = 'hasDefaultValue';
                $item .= '<input type="text" ' . $this->getPlaceholderAttribute($table, $field, $config, $row) . 'id="' . $inputId . '" ' . 'class="' . implode(' ', $cssClasses) . '" ' . 'name="' . $PA['itemFormElName'] . '_hr" ' . 'value=""' . 'style="' . $cssStyle . '" ' . 'maxlength="' . $mLgd . '" ' . 'onchange="' . htmlspecialchars($iOnChange) . '"' . $PA['onFocus'] . ' />';
                // This is the EDITABLE form field.
                $item .= '<input type="hidden" name="' . $PA['itemFormElName'] . '" value="' . htmlspecialchars($PA['itemFormElValue']) . '" />';
                // This is the ACTUAL form field - values from the EDITABLE field must be transferred to this field which is the one that is written to the database.
                $item .= $fieldAppendix . '</span><div style="clear:both;"></div>';
                $this->extJSCODE .= 'typo3form.fieldSet(' . $paramsList . ');';
                // Going through all custom evaluations configured for this field
                foreach ($evalList as $evalData) {
                        $evalObj = GeneralUtility::getUserObj($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tce']['formevals'][$evalData] . ':&' . $evalData);
                        if (is_object($evalObj) && method_exists($evalObj, 'returnFieldJS')) {
                                $this->extJSCODE .= '
TBE_EDITOR.customEvalFunctions[\'' . $evalData . '\'] = function(value) {
' . $evalObj->returnFieldJS() . '
}
';
                        }
                }
                // Creating an alternative item without the JavaScript handlers.
                $altItem = '<input type="hidden" name="' . $PA['itemFormElName'] . '_hr" value="" />';
                $altItem .= '<input type="hidden" name="' . $PA['itemFormElName'] . '" value="' . htmlspecialchars($PA['itemFormElValue']) . '" />';
                // Wrap a wizard around the item?
                $item = $this->renderWizards(array($item, $altItem), $config['wizards'], $table, $row, $field, $PA, $PA['itemFormElName'] . '_hr', $specConf);

                return $item;
        }

        /**
         * Renders a view widget to handle and activate NULL values.
         * The widget is enabled by using 'null' in the 'eval' TCA definition.
         *
         * @param string $table Name of the table
         * @param string $field Name of the field
         * @param array $row Accordant data of the record row
         * @param array $PA Parameters array with rendering instructions
         * @return string Widget (if any).
         */
        protected function renderNullValueWidget($table, $field, array $row, array $PA) {
                $widget = '';

                $config = $PA['fieldConf']['config'];
                if (!empty($config['eval']) && GeneralUtility::inList($config['eval'], 'null') && (empty($config['mode']) || $config['mode'] !== 'useOrOverridePlaceholder')) {
                        $isNull = ($PA['itemFormElValue'] === NULL);

                        $checked = ($isNull ? '' : ' checked="checked"');
                        $onChange = htmlspecialchars(
                                'typo3form.fieldSetNull(\'' . $PA['itemFormElName'] . '\', !this.checked)'
                        );

                        $widget = '<span class="t3-tceforms-widget-null-wrapper">' .
                                '<input type="hidden" name="' . $PA['itemFormElNameActive'] . '" value="0" />' .
                                '<input type="checkbox" name="' . $PA['itemFormElNameActive'] . '" value="1" onchange="' . $onChange . '"' . $checked . ' />' .
                        '</span>';
                }

                return $widget;
        }

        /**
         * Determines whether the current field value is considered as NULL value.
         * Using NULL values is enabled by using 'null' in the 'eval' TCA definition.
         *
         * @param string $table Name of the table
         * @param string $field Name of the field
         * @param array $row Accordant data
         * @param array $PA Parameters array with rendering instructions
         * @return boolean
         */
        protected function isDisabledNullValueField($table, $field, array $row, array $PA) {
                $result = FALSE;

                $config = $PA['fieldConf']['config'];
                if ($PA['itemFormElValue'] === NULL && !empty($config['eval'])
                        && GeneralUtility::inList($config['eval'], 'null')
                        && (empty($config['mode']) || $config['mode'] !== 'useOrOverridePlaceholder')) {

                        $result = TRUE;
                }

                return $result;
        }

        /**
         * Generation of TCEform elements of the type "text"
         * This will render a <textarea> OR RTE area form field, possibly with various control/validation features
         *
         * @param string $table The table name of the record
         * @param string $field The field name which this element is supposed to edit
         * @param array $row The record data array where the value(s) for the field can be found
         * @param array $PA An array with additional configuration options.
         * @return string The HTML code for the TCEform field
         * @todo Define visibility
         */
        public function getSingleField_typeText($table, $field, $row, &$PA) {
                // Init config:
                $config = $PA['fieldConf']['config'];
                $evalList = GeneralUtility::trimExplode(',', $config['eval'], TRUE);
                if ($this->renderReadonly || $config['readOnly']) {
                        return $this->getSingleField_typeNone_render($config, $PA['itemFormElValue']);
                }
                // Setting columns number:
                $cols = MathUtility::forceIntegerInRange($config['cols'] ? $config['cols'] : 30, 5, $this->maxTextareaWidth);
                // Setting number of rows:
                $origRows = ($rows = MathUtility::forceIntegerInRange($config['rows'] ? $config['rows'] : 5, 1, 20));
                if (strlen($PA['itemFormElValue']) > $this->charsPerRow * 2) {
                        $cols = $this->maxTextareaWidth;
                        $rows = MathUtility::forceIntegerInRange(round(strlen($PA['itemFormElValue']) / $this->charsPerRow), count(explode(LF, $PA['itemFormElValue'])), 20);
                        if ($rows < $origRows) {
                                $rows = $origRows;
                        }
                }
                if (in_array('required', $evalList)) {
                        $this->requiredFields[$table . '_' . $row['uid'] . '_' . $field] = $PA['itemFormElName'];
                }
                // Init RTE vars:
                // Set TRUE, if the RTE is loaded; If not a normal textarea is shown.
                $RTEwasLoaded = 0;
                // Set TRUE, if the RTE would have been loaded if it wasn't for the disable-RTE flag in the bottom of the page...
                $RTEwouldHaveBeenLoaded = 0;
                // "Extra" configuration; Returns configuration for the field based on settings found in the "types" fieldlist. Traditionally, this is where RTE configuration has been found.
                $specConf = $this->getSpecConfFromString($PA['extra'], $PA['fieldConf']['defaultExtras']);
                // Setting up the altItem form field, which is a hidden field containing the value
                $altItem = '<input type="hidden" name="' . htmlspecialchars($PA['itemFormElName']) . '" value="' . htmlspecialchars($PA['itemFormElValue']) . '" />';
                // If RTE is generally enabled (TYPO3_CONF_VARS and user settings)
                if ($this->RTEenabled) {
                        $p = BackendUtility::getSpecConfParametersFromArray($specConf['rte_transform']['parameters']);
                        // If the field is configured for RTE and if any flag-field is not set to disable it.
                        if (isset($specConf['richtext']) && (!$p['flag'] || !$row[$p['flag']])) {
                                BackendUtility::fixVersioningPid($table, $row);
                                list($tscPID, $thePidValue) = $this->getTSCpid($table, $row['uid'], $row['pid']);
                                // If the pid-value is not negative (that is, a pid could NOT be fetched)
                                if ($thePidValue >= 0) {
                                        $RTEsetup = $this->getBackendUserAuthentication()->getTSConfig('RTE', BackendUtility::getPagesTSconfig($tscPID));
                                        $RTEtypeVal = BackendUtility::getTCAtypeValue($table, $row);
                                        $thisConfig = BackendUtility::RTEsetup($RTEsetup['properties'], $table, $field, $RTEtypeVal);
                                        if (!$thisConfig['disabled']) {
                                                if (!$this->disableRTE) {
                                                        $this->RTEcounter++;
                                                        // Find alternative relative path for RTE images/links:
                                                        $eFile = RteHtmlParser::evalWriteFile($specConf['static_write'], $row);
                                                        $RTErelPath = is_array($eFile) ? dirname($eFile['relEditFile']) : '';
                                                        // Get RTE object, draw form and set flag:
                                                        $RTEobj = BackendUtility::RTEgetObj();
                                                        $item = $RTEobj->drawRTE($this, $table, $field, $row, $PA, $specConf, $thisConfig, $RTEtypeVal, $RTErelPath, $thePidValue);
                                                        // Wizard:
                                                        $item = $this->renderWizards(array($item, $altItem), $config['wizards'], $table, $row, $field, $PA, $PA['itemFormElName'], $specConf, 1);
                                                        $RTEwasLoaded = 1;
                                                } else {
                                                        $RTEwouldHaveBeenLoaded = 1;
                                                        $this->commentMessages[] = $PA['itemFormElName'] . ': RTE is disabled by the on-page RTE-flag (probably you can enable it by the check-box in the bottom of this page!)';
                                                }
                                        } else {
                                                $this->commentMessages[] = $PA['itemFormElName'] . ': RTE is disabled by the Page TSconfig, "RTE"-key (eg. by RTE.default.disabled=0 or such)';
                                        }
                                } else {
                                        $this->commentMessages[] = $PA['itemFormElName'] . ': PID value could NOT be fetched. Rare error, normally with new records.';
                                }
                        } else {
                                if (!isset($specConf['richtext'])) {
                                        $this->commentMessages[] = $PA['itemFormElName'] . ': RTE was not configured for this field in TCA-types';
                                }
                                if (!(!$p['flag'] || !$row[$p['flag']])) {
                                        $this->commentMessages[] = $PA['itemFormElName'] . ': Field-flag (' . $PA['flag'] . ') has been set to disable RTE!';
                                }
                        }
                }
                // Display ordinary field if RTE was not loaded.
                if (!$RTEwasLoaded) {
                        // Show message, if no RTE (field can only be edited with RTE!)
                        if ($specConf['rte_only']) {
                                $item = '<p><em>' . htmlspecialchars($this->getLL('l_noRTEfound')) . '</em></p>';
                        } else {
                                if ($specConf['nowrap']) {
                                        $wrap = 'off';
                                } else {
                                        $wrap = $config['wrap'] ?: 'virtual';
                                }
                                $classes = array();
                                if ($specConf['fixed-font']) {
                                        $classes[] = 'fixed-font';
                                }
                                if ($specConf['enable-tab']) {
                                        $classes[] = 'enable-tab';
                                }
                                $formWidthText = $this->formWidthText($cols, $wrap);
                                // Extract class attributes from $formWidthText (otherwise it would be added twice to the output)
                                $res = array();
                                if (preg_match('/ class="(.+?)"/', $formWidthText, $res)) {
                                        $formWidthText = str_replace(' class="' . $res[1] . '"', '', $formWidthText);
                                        $classes = array_merge($classes, explode(' ', $res[1]));
                                }
                                if (count($classes)) {
                                        $class = ' class="tceforms-textarea ' . implode(' ', $classes) . '"';
                                } else {
                                        $class = 'tceforms-textarea';
                                }
                                $evalList = GeneralUtility::trimExplode(',', $config['eval'], TRUE);
                                foreach ($evalList as $func) {
                                        switch ($func) {
                                                case 'required':
                                                        $this->registerRequiredProperty('field', $table . '_' . $row['uid'] . '_' . $field, $PA['itemFormElName']);
                                                        break;
                                                default:
                                                        // Pair hook to the one in \TYPO3\CMS\Core\DataHandling\DataHandler::checkValue_input_Eval() and \TYPO3\CMS\Core\DataHandling\DataHandler::checkValue_text_Eval()
                                                        $evalObj = GeneralUtility::getUserObj($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tce']['formevals'][$func] . ':&' . $func);
                                                        if (is_object($evalObj) && method_exists($evalObj, 'deevaluateFieldValue')) {
                                                                $_params = array(
                                                                        'value' => $PA['itemFormElValue']
                                                                );
                                                                $PA['itemFormElValue'] = $evalObj->deevaluateFieldValue($_params);
                                                        }
                                        }
                                }
                                $iOnChange = implode('', $PA['fieldChangeFunc']);
                                $item .= '
                                                        <textarea ' . 'id="' . uniqid('tceforms-textarea-') . '" ' . 'name="' . $PA['itemFormElName'] . '"' . $formWidthText . $class . ' ' . 'rows="' . $rows . '" ' . 'wrap="' . $wrap . '" ' . 'onchange="' . htmlspecialchars($iOnChange) . '"' . $this->getPlaceholderAttribute($table, $field, $config, $row) . $PA['onFocus'] . '>' . GeneralUtility::formatForTextarea($PA['itemFormElValue']) . '</textarea>';
                                $item = $this->renderWizards(array($item, $altItem), $config['wizards'], $table, $row, $field, $PA, $PA['itemFormElName'], $specConf, $RTEwouldHaveBeenLoaded);
                        }
                }
                // Return field HTML:
                return $item;
        }

        /**
         * Generation of TCEform elements of the type "check"
         * This will render a check-box OR an array of checkboxes
         *
         * @param string $table The table name of the record
         * @param string $field The field name which this element is supposed to edit
         * @param array $row The record data array where the value(s) for the field can be found
         * @param array $PA An array with additional configuration options.
         * @return string The HTML code for the TCEform field
         * @todo Define visibility
         */
        public function getSingleField_typeCheck($table, $field, $row, &$PA) {
                $config = $PA['fieldConf']['config'];
                $item = '';
                $disabled = '';
                if ($this->renderReadonly || $config['readOnly']) {
                        $disabled = ' disabled="disabled"';
                }
                // Traversing the array of items:
                $selItems = $this->initItemArray($PA['fieldConf']);
                if ($config['itemsProcFunc']) {
                        $selItems = $this->procItems($selItems, $PA['fieldTSConfig']['itemsProcFunc.'], $config, $table, $row, $field);
                }
                if (!count($selItems)) {
                        $selItems[] = array('', '');
                }
                $thisValue = (int)$PA['itemFormElValue'];
                $cols = (int)$config['cols'];
                $selItemsCount = count($selItems);
                if ($cols > 1) {
                        $item .= '<table border="0" cellspacing="0" cellpadding="0" class="typo3-TCEforms-checkboxArray">';
                        for ($c = 0; $c < $selItemsCount; $c++) {
                                $p = $selItems[$c];
                                if (!($c % $cols)) {
                                        $item .= '<tr>';
                                }
                                $cBP = $this->checkBoxParams($PA['itemFormElName'], $thisValue, $c, count($selItems), implode('', $PA['fieldChangeFunc']));
                                $cBName = $PA['itemFormElName'] . '_' . $c;
                                $cBID = $PA['itemFormElID'] . '_' . $c;
                                $item .= '<td nowrap="nowrap">' . '<input type="checkbox"' . $this->insertDefStyle('check') . ' value="1" name="' . $cBName . '"' . $cBP . $disabled . ' id="' . $cBID . '" />' . $this->wrapLabels(('<label for="' . $cBID . '">' . htmlspecialchars($p[0]) . '</label>&nbsp;')) . '</td>';
                                if ($c % $cols + 1 == $cols) {
                                        $item .= '</tr>';
                                }
                        }
                        if ($c % $cols) {
                                $rest = $cols - $c % $cols;
                                for ($c = 0; $c < $rest; $c++) {
                                        $item .= '<td></td>';
                                }
                                if ($c > 0) {
                                        $item .= '</tr>';
                                }
                        }
                        $item .= '</table>';
                } else {
                        for ($c = 0; $c < $selItemsCount; $c++) {
                                $p = $selItems[$c];
                                $cBP = $this->checkBoxParams($PA['itemFormElName'], $thisValue, $c, count($selItems), implode('', $PA['fieldChangeFunc']));
                                $cBName = $PA['itemFormElName'] . '_' . $c;
                                $cBID = $PA['itemFormElID'] . '_' . $c;
                                $item .= ($c > 0 ? '<br />' : '') . '<input type="checkbox"' . $this->insertDefStyle('check') . ' value="1" name="' . $cBName . '"' . $cBP . $PA['onFocus'] . $disabled . ' id="' . $cBID . '" />' . $this->wrapLabels(('<label for="' . $cBID . '">' . htmlspecialchars($p[0]) . '</label>'));
                        }
                }
                if (!$disabled) {
                        $item .= '<input type="hidden" name="' . $PA['itemFormElName'] . '" value="' . htmlspecialchars($thisValue) . '" />';
                }
                return $item;
        }

        /**
         * Generation of TCEform elements of the type "radio"
         * This will render a series of radio buttons.
         *
         * @param string $table The table name of the record
         * @param string $field The field name which this element is supposed to edit
         * @param array $row The record data array where the value(s) for the field can be found
         * @param array $PA An array with additional configuration options.
         * @return string The HTML code for the TCEform field
         * @todo Define visibility
         */
        public function getSingleField_typeRadio($table, $field, $row, &$PA) {
                $config = $PA['fieldConf']['config'];
                $item = '';
                $disabled = '';
                if ($this->renderReadonly || $config['readOnly']) {
                        $disabled = ' disabled="disabled"';
                }
                // Get items for the array:
                $selItems = $this->initItemArray($PA['fieldConf']);
                if ($config['itemsProcFunc']) {
                        $selItems = $this->procItems($selItems, $PA['fieldTSConfig']['itemsProcFunc.'], $config, $table, $row, $field);
                }
                // Traverse the items, making the form elements:
                $selItemsCount = count($selItems);
                for ($c = 0; $c < $selItemsCount; $c++) {
                        $p = $selItems[$c];
                        $rID = $PA['itemFormElID'] . '_' . $c;
                        $rOnClick = implode('', $PA['fieldChangeFunc']);
                        $rChecked = (string)$p[1] === (string)$PA['itemFormElValue'] ? ' checked="checked"' : '';
                        $item .= '<input type="radio"' . $this->insertDefStyle('radio') . ' name="' . $PA['itemFormElName'] . '" value="' . htmlspecialchars($p[1]) . '" onclick="' . htmlspecialchars($rOnClick) . '"' . $rChecked . $PA['onFocus'] . $disabled . ' id="' . $rID . '" />
                                        <label for="' . $rID . '">' . htmlspecialchars($p[0]) . '</label>
                                        <br />';
                }
                return $item;
        }

        /**
         * Generation of TCEform elements of the type "select"
         * This will render a selector box element, or possibly a special construction with two selector boxes. That depends on configuration.
         *
         * @param string $table The table name of the record
         * @param string $field The field name which this element is supposed to edit
         * @param array $row The record data array where the value(s) for the field can be found
         * @param array $PA An array with additional configuration options.
         * @return string The HTML code for the TCEform field
         * @todo Define visibility
         */
        public function getSingleField_typeSelect($table, $field, $row, &$PA) {
                // Field configuration from TCA:
                $config = $PA['fieldConf']['config'];
                $disabled = '';
                if ($this->renderReadonly || $config['readOnly']) {
                        $disabled = ' disabled="disabled"';
                }
                // "Extra" configuration; Returns configuration for the field based on settings found in the "types" fieldlist. See http://typo3.org/documentation/document-library/doc_core_api/Wizards_Configuratio/.
                $specConf = $this->getSpecConfFromString($PA['extra'], $PA['fieldConf']['defaultExtras']);
                $selItems = $this->getSelectItems($table, $field, $row, $PA);

                // Creating the label for the "No Matching Value" entry.
                $nMV_label = isset($PA['fieldTSConfig']['noMatchingValue_label']) ? $this->sL($PA['fieldTSConfig']['noMatchingValue_label']) : '[ ' . $this->getLL('l_noMatchingValue') . ' ]';
                // Prepare some values:
                $maxitems = (int)$config['maxitems'];
                // If a SINGLE selector box...
                if ($maxitems <= 1 && $config['renderMode'] !== 'tree') {
                        $item = $this->getSingleField_typeSelect_single($table, $field, $row, $PA, $config, $selItems, $nMV_label);
                } elseif ($config['renderMode'] === 'checkbox') {
                        // Checkbox renderMode
                        $item = $this->getSingleField_typeSelect_checkbox($table, $field, $row, $PA, $config, $selItems, $nMV_label);
                } elseif ($config['renderMode'] === 'singlebox') {
                        // Single selector box renderMode
                        $item = $this->getSingleField_typeSelect_singlebox($table, $field, $row, $PA, $config, $selItems, $nMV_label);
                } elseif ($config['renderMode'] === 'tree') {
                        // Tree renderMode
                        $treeClass = GeneralUtility::makeInstance('TYPO3\\CMS\\Backend\\Form\\Element\\TreeElement', $this);
                        $item = $treeClass->renderField($table, $field, $row, $PA, $config, $selItems, $nMV_label);
                        // Register the required number of elements
                        $minitems = MathUtility::forceIntegerInRange($config['minitems'], 0);
                        $this->registerRequiredProperty('range', $PA['itemFormElName'], array($minitems, $maxitems, 'imgName' => $table . '_' . $row['uid'] . '_' . $field));
                } else {
                        // Traditional multiple selector box:
                        $item = $this->getSingleField_typeSelect_multiple($table, $field, $row, $PA, $config, $selItems, $nMV_label);
                }
                // Wizards:
                if (!$disabled) {
                        $altItem = '<input type="hidden" name="' . $PA['itemFormElName'] . '" value="' . htmlspecialchars($PA['itemFormElValue']) . '" />';
                        $item = $this->renderWizards(array($item, $altItem), $config['wizards'], $table, $row, $field, $PA, $PA['itemFormElName'], $specConf);
                }
                return $item;
        }

        /**
         * Collects the items for a select field by reading the configured
         * select items from the configuration and / or by collecting them
         * from a foreign table.
         *
         * @param string $table The table name of the record
         * @param string $fieldName The select field name
         * @param array $row The record data array where the value(s) for the field can be found
         * @param array $PA An array with additional configuration options.
         * @return array
         */
        public function getSelectItems($table, $fieldName, array $row, array $PA) {
                $config = $PA['fieldConf']['config'];

                // Getting the selector box items from the system
                $selectItems = $this->addSelectOptionsToItemArray(
                        $this->initItemArray($PA['fieldConf']),
                        $PA['fieldConf'],
                        $this->setTSconfig($table, $row),
                        $fieldName
                );

                // Possibly filter some items:
                $selectItems = GeneralUtility::keepItemsInArray(
                        $selectItems,
                        $PA['fieldTSConfig']['keepItems'],
                        function ($value) {
                                return $value[1];
                        }
                );

                // Possibly add some items:
                $selectItems = $this->addItems($selectItems, $PA['fieldTSConfig']['addItems.']);

                // Process items by a user function:
                if (isset($config['itemsProcFunc']) && $config['itemsProcFunc']) {
                        $selectItems = $this->procItems($selectItems, $PA['fieldTSConfig']['itemsProcFunc.'], $config, $table, $row, $fieldName);
                }

                // Possibly remove some items:
                $removeItems = GeneralUtility::trimExplode(',', $PA['fieldTSConfig']['removeItems'], TRUE);
                foreach ($selectItems as $selectItemIndex => $selectItem) {

                        // Checking languages and authMode:
                        $languageDeny = FALSE;
                        $beUserAuth = $this->getBackendUserAuthentication();
                        if (
                                !empty($GLOBALS['TCA'][$table]['ctrl']['languageField'])
                                && $GLOBALS['TCA'][$table]['ctrl']['languageField'] === $fieldName
                                && !$beUserAuth->checkLanguageAccess($selectItem[1])
                        ) {
                                $languageDeny = TRUE;
                        }

                        $authModeDeny = FALSE;
                        if (
                                ($config['form_type'] === 'select')
                                && $config['authMode']
                                && !$beUserAuth->checkAuthMode($table, $fieldName, $selectItem[1], $config['authMode'])
                        ) {
                                $authModeDeny = TRUE;
                        }

                        if (in_array($selectItem[1], $removeItems) || $languageDeny || $authModeDeny) {
                                unset($selectItems[$selectItemIndex]);
                        } elseif (isset($PA['fieldTSConfig']['altLabels.'][$selectItem[1]])) {
                                $selectItems[$selectItemIndex][0] = htmlspecialchars($this->sL($PA['fieldTSConfig']['altLabels.'][$selectItem[1]]));
                        }

                        // Removing doktypes with no access:
                        if (($table === 'pages' || $table === 'pages_language_overlay') && $fieldName === 'doktype') {
                                if (!($beUserAuth->isAdmin() || GeneralUtility::inList($beUserAuth->groupData['pagetypes_select'], $selectItem[1]))) {
                                        unset($selectItems[$selectItemIndex]);
                                }
                        }
                }

                return $selectItems;
        }

        /**
         * Creates a single-selector box
         * (Render function for getSingleField_typeSelect())
         *
         * @param string $table See getSingleField_typeSelect()
         * @param string $field See getSingleField_typeSelect()
         * @param array $row See getSingleField_typeSelect()
         * @param array $PA See getSingleField_typeSelect()
         * @param array $config (Redundant) content of $PA['fieldConf']['config'] (for convenience)
         * @param array $selItems Items available for selection
         * @param string $nMV_label Label for no-matching-value
         * @return string The HTML code for the item
         * @see getSingleField_typeSelect()
         * @todo Define visibility
         */
        public function getSingleField_typeSelect_single($table, $field, $row, &$PA, $config, $selItems, $nMV_label) {
                // check against inline uniqueness
                $inlineParent = $this->inline->getStructureLevel(-1);
                if (is_array($inlineParent) && $inlineParent['uid']) {
                        if ($inlineParent['config']['foreign_table'] == $table && $inlineParent['config']['foreign_unique'] == $field) {
                                $uniqueIds = $this->inline->inlineData['unique'][$this->inline->inlineNames['object'] . InlineElement::Structure_Separator . $table]['used'];
                                $PA['fieldChangeFunc']['inlineUnique'] = 'inline.updateUnique(this,\'' . $this->inline->inlineNames['object'] . InlineElement::Structure_Separator . $table . '\',\'' . $this->inline->inlineNames['form'] . '\',\'' . $row['uid'] . '\');';
                        }
                        // hide uid of parent record for symmetric relations
                        if ($inlineParent['config']['foreign_table'] == $table && ($inlineParent['config']['foreign_field'] == $field || $inlineParent['config']['symmetric_field'] == $field)) {
                                $uniqueIds[] = $inlineParent['uid'];
                        }
                }
                // Initialization:
                $c = 0;
                $sI = 0;
                $noMatchingValue = 1;
                $opt = array();
                $selicons = array();
                $onlySelectedIconShown = 0;
                $size = (int)$config['size'];
                // Style set on <select/>
                $selectedStyle = '';
                $item = '';
                $disabled = '';
                // TODO: icon is used but never assigned
                $onChangeIcon = '';
                if ($this->renderReadonly || $config['readOnly']) {
                        $disabled = ' disabled="disabled"';
                        $onlySelectedIconShown = 1;
                }
                // Register as required if minitems is greater than zero
                if (($minItems = MathUtility::forceIntegerInRange($config['minitems'], 0)) > 0) {
                        $this->registerRequiredProperty('field', $table . '_' . $row['uid'] . '_' . $field, $PA['itemFormElName']);
                }

                // Icon configuration:
                if ($config['suppress_icons'] == 'IF_VALUE_FALSE') {
                        $suppressIcons = !$PA['itemFormElValue'] ? 1 : 0;
                } elseif ($config['suppress_icons'] == 'ONLY_SELECTED') {
                        $suppressIcons = 0;
                        $onlySelectedIconShown = 1;
                } elseif ($config['suppress_icons']) {
                        $suppressIcons = 1;
                } else {
                        $suppressIcons = 0;
                }
                // Traverse the Array of selector box items:
                $optGroupStart = array();
                $optGroupOpen = FALSE;
                $classesForSelectTag = array();
                foreach ($selItems as $p) {
                        $sM = (string)$PA['itemFormElValue'] === (string)$p[1] ? ' selected="selected"' : '';
                        if ($sM) {
                                $sI = $c;
                                $noMatchingValue = 0;
                        }
                        // Getting style attribute value (for icons):
                        if ($config['iconsInOptionTags']) {
                                $styleAttrValue = $this->optionTagStyle($p[2]);
                                if ($sM) {
                                        list($selectIconFile, $selectIconInfo) = $this->getIcon($p[2]);
                                        if (!empty($selectIconInfo)) {
                                                $selectedStyle = ' style="background-image:url(' . $selectIconFile . ');"';
                                                $classesForSelectTag[] = 'typo3-TCEforms-select-selectedItemWithBackgroundImage';
                                        }
                                }
                        }
                        // Compiling the <option> tag:
                        if (!($p[1] != $PA['itemFormElValue'] && is_array($uniqueIds) && in_array($p[1], $uniqueIds))) {
                                if ($p[1] === '--div--') {
                                        $optGroupStart[0] = $p[0];
                                        if ($config['iconsInOptionTags']) {
                                                $optGroupStart[1] = $this->optgroupTagStyle($p[2]);
                                        } else {
                                                $optGroupStart[1] = $styleAttrValue;
                                        }
                                } else {
                                        if (count($optGroupStart)) {
                                                // Closing last optgroup before next one starts
                                                if ($optGroupOpen) {
                                                        $opt[] = '</optgroup>' . LF;
                                                }
                                                $opt[] = '<optgroup label="' . htmlspecialchars($optGroupStart[0], ENT_COMPAT, 'UTF-8', FALSE) . '"' . ($optGroupStart[1] ? ' style="' . htmlspecialchars($optGroupStart[1]) . '"' : '') . ' class="c-divider">' . LF;
                                                $optGroupOpen = TRUE;
                                                $c--;
                                                $optGroupStart = array();
                                        }
                                        $opt[] = '<option value="' . htmlspecialchars($p[1]) . '"' . $sM . ($styleAttrValue ? ' style="' . htmlspecialchars($styleAttrValue) . '"' : '') . '>' . htmlspecialchars($p[0], ENT_COMPAT, 'UTF-8', FALSE) . '</option>' . LF;
                                }
                        }
                        // If there is an icon for the selector box (rendered in selicon-table below)...:
                        // if there is an icon ($p[2]), icons should be shown, and, if only selected are visible, is it selected
                        if ($p[2] && !$suppressIcons && (!$onlySelectedIconShown || $sM)) {
                                list($selIconFile, $selIconInfo) = $this->getIcon($p[2]);
                                if (!empty($selIconInfo)) {
                                        $iOnClick = $this->elName($PA['itemFormElName']) . '.selectedIndex=' . $c . '; ' . $this->elName($PA['itemFormElName']) . '.style.backgroundImage=' . $this->elName($PA['itemFormElName']) . '.options[' . $c . '].style.backgroundImage; ' . implode('', $PA['fieldChangeFunc']) . 'this.blur(); return false;';
                                } else {
                                        $iOnClick = $this->elName($PA['itemFormElName']) . '.selectedIndex=' . $c . '; ' . $this->elName($PA['itemFormElName']) . '.className=' . $this->elName($PA['itemFormElName']) . '.options[' . $c . '].className; ' . implode('', $PA['fieldChangeFunc']) . 'this.blur(); return false;';
                                }
                                $selicons[] = array(
                                        (!$onlySelectedIconShown ? '<a href="#" onclick="' . htmlspecialchars($iOnClick) . '">' : '') . $this->getIconHtml($p[2], htmlspecialchars($p[0]), htmlspecialchars($p[0])) . (!$onlySelectedIconShown ? '</a>' : ''),
                                        $c,
                                        $sM
                                );
                        }
                        $c++;
                }
                // Closing optgroup if open
                if ($optGroupOpen) {
                        $opt[] = '</optgroup>';
                }
                // No-matching-value:
                if ($PA['itemFormElValue'] && $noMatchingValue && !$PA['fieldTSConfig']['disableNoMatchingValueElement'] && !$config['disableNoMatchingValueElement']) {
                        $nMV_label = @sprintf($nMV_label, $PA['itemFormElValue']);
                        $opt[] = '<option value="' . htmlspecialchars($PA['itemFormElValue']) . '" selected="selected">' . htmlspecialchars($nMV_label) . '</option>';
                }
                // Create item form fields:
                $sOnChange = 'if (this.options[this.selectedIndex].value==\'--div--\') {this.selectedIndex=' . $sI . ';} ' . implode('', $PA['fieldChangeFunc']);
                if (!$disabled) {
                        // MUST be inserted before the selector - else is the value of the hiddenfield here mysteriously submitted...
                        $item .= '<input type="hidden" name="' . $PA['itemFormElName'] . '_selIconVal" value="' . htmlspecialchars($sI) . '" />';
                }
                if ($config['iconsInOptionTags']) {
                        $classesForSelectTag[] = 'icon-select';
                }
                $item .= '<select' . $selectedStyle . ' id="' . uniqid('tceforms-select-') . '" name="' . $PA['itemFormElName'] . '"' . $this->insertDefStyle('select', implode(' ', $classesForSelectTag)) . ($size ? ' size="' . $size . '"' : '') . ' onchange="' . htmlspecialchars(($onChangeIcon . $sOnChange)) . '"' . $PA['onFocus'] . $disabled . '>';
                $item .= implode('', $opt);
                $item .= '</select>';
                // Create icon table:
                if (count($selicons) && !$config['noIconsBelowSelect']) {
                        $item .= '<table border="0" cellpadding="0" cellspacing="0" class="typo3-TCEforms-selectIcons">';
                        $selicon_cols = (int)$config['selicon_cols'];
                        if (!$selicon_cols) {
                                $selicon_cols = count($selicons);
                        }
                        $sR = ceil(count($selicons) / $selicon_cols);
                        $selicons = array_pad($selicons, $sR * $selicon_cols, '');
                        for ($sa = 0; $sa < $sR; $sa++) {
                                $item .= '<tr>';
                                for ($sb = 0; $sb < $selicon_cols; $sb++) {
                                        $sk = $sa * $selicon_cols + $sb;
                                        $imgN = 'selIcon_' . $table . '_' . $row['uid'] . '_' . $field . '_' . $selicons[$sk][1];
                                        $imgS = $selicons[$sk][2] ? $this->backPath . 'gfx/content_selected.gif' : 'clear.gif';
                                        $item .= '<td><img name="' . htmlspecialchars($imgN) . '" src="' . $imgS . '" width="7" height="10" alt="" /></td>';
                                        $item .= '<td>' . $selicons[$sk][0] . '</td>';
                                }
                                $item .= '</tr>';
                        }
                        $item .= '</table>';
                }
                return $item;
        }

        /**
         * Creates a checkbox list (renderMode = "checkbox")
         * (Render function for getSingleField_typeSelect())
         *
         * @param string $table See getSingleField_typeSelect()
         * @param string $field See getSingleField_typeSelect()
         * @param array $row See getSingleField_typeSelect()
         * @param array $PA See getSingleField_typeSelect()
         * @param array $config (Redundant) content of $PA['fieldConf']['config'] (for convenience)
         * @param array $selItems Items available for selection
         * @param string $nMV_label Label for no-matching-value
         * @return string The HTML code for the item
         * @see getSingleField_typeSelect()
         * @todo Define visibility
         */
        public function getSingleField_typeSelect_checkbox($table, $field, $row, &$PA, $config, $selItems, $nMV_label) {
                if (empty($selItems)) {
                        return '';
                }
                // Get values in an array (and make unique, which is fine because there can be no duplicates anyway):
                $itemArray = array_flip($this->extractValuesOnlyFromValueLabelList($PA['itemFormElValue']));
                $item = '';
                $disabled = '';
                if ($this->renderReadonly || $config['readOnly']) {
                        $disabled = ' disabled="disabled"';
                }
                // Traverse the Array of selector box items:
                $tRows = array();
                $c = 0;
                if (!$disabled) {
                        $sOnChange = implode('', $PA['fieldChangeFunc']);
                        // Used to accumulate the JS needed to restore the original selection.
                        $setAll = array();
                        $unSetAll = array();
                        foreach ($selItems as $p) {
                                // Non-selectable element:
                                if ($p[1] === '--div--') {
                                        $selIcon = '';
                                        if (isset($p[2]) && $p[2] != 'empty-emtpy') {
                                                $selIcon = $this->getIconHtml($p[2]);
                                        }
                                        $tRows[] = '
                                                <tr class="c-header">
                                                        <td colspan="3">' . $selIcon . htmlspecialchars($p[0]) . '</td>
                                                </tr>';
                                } else {
                                        // Selected or not by default:
                                        $sM = '';
                                        if (isset($itemArray[$p[1]])) {
                                                $sM = ' checked="checked"';
                                                unset($itemArray[$p[1]]);
                                        }
                                        // Icon:
                                        if ($p[2]) {
                                                $selIcon = $p[2];
                                        } else {
                                                $selIcon = IconUtility::getSpriteIcon('empty-empty');
                                        }
                                        // Compile row:
                                        $rowId = uniqid('select_checkbox_row_');
                                        $onClickCell = $this->elName(($PA['itemFormElName'] . '[' . $c . ']')) . '.checked=!' . $this->elName(($PA['itemFormElName'] . '[' . $c . ']')) . '.checked;';
                                        $onClick = 'this.attributes.getNamedItem("class").nodeValue = ' . $this->elName(($PA['itemFormElName'] . '[' . $c . ']')) . '.checked ? "c-selectedItem" : "c-unselectedItem";';
                                        $setAll[] = $this->elName(($PA['itemFormElName'] . '[' . $c . ']')) . '.checked=1;';
                                        $setAll[] .= '$(\'' . $rowId . '\').removeClassName(\'c-unselectedItem\');$(\'' . $rowId . '\').addClassName(\'c-selectedItem\');';
                                        $unSetAll[] = $this->elName(($PA['itemFormElName'] . '[' . $c . ']')) . '.checked=0;';
                                        $unSetAll[] .= '$(\'' . $rowId . '\').removeClassName(\'c-selectedItem\');$(\'' . $rowId . '\').addClassName(\'c-unselectedItem\');';
                                        $restoreCmd[] = $this->elName(($PA['itemFormElName'] . '[' . $c . ']')) . '.checked=' . ($sM ? 1 : 0) . ';' . '$(\'' . $rowId . '\').removeClassName(\'c-selectedItem\');$(\'' . $rowId . '\').removeClassName(\'c-unselectedItem\');' . '$(\'' . $rowId . '\').addClassName(\'c-' . ($sM ? '' : 'un') . 'selectedItem\');';
                                        // Check if some help text is available
                                        // Since TYPO3 4.5 help text is expected to be an associative array
                                        // with two key, "title" and "description"
                                        // For the sake of backwards compatibility, we test if the help text
                                        // is a string and use it as a description (this could happen if items
                                        // are modified with an itemProcFunc)
                                        $hasHelp = FALSE;
                                        $help = '';
                                        $helpArray = array();
                                        if (is_array($p[3]) && count($p[3]) > 0 || !empty($p[3])) {
                                                $hasHelp = TRUE;
                                                if (is_array($p[3])) {
                                                        $helpArray = $p[3];
                                                } else {
                                                        $helpArray['description'] = $p[3];
                                                }
                                        }
                                        $label = htmlspecialchars($p[0], ENT_COMPAT, 'UTF-8', FALSE);
                                        if ($hasHelp) {
                                                $help = BackendUtility::wrapInHelp('', '', '', $helpArray);
                                        }
                                        $tRows[] = '
                                                <tr id="' . $rowId . '" class="' . ($sM ? 'c-selectedItem' : 'c-unselectedItem') . '" onclick="' . htmlspecialchars($onClick) . '" style="cursor: pointer;">
                                                        <td class="c-checkbox"><input type="checkbox"' . $this->insertDefStyle('check') . ' name="' . htmlspecialchars(($PA['itemFormElName'] . '[' . $c . ']')) . '" value="' . htmlspecialchars($p[1]) . '"' . $sM . ' onclick="' . htmlspecialchars($sOnChange) . '"' . $PA['onFocus'] . ' /></td>
                                                        <td class="c-labelCell" onclick="' . htmlspecialchars($onClickCell) . '">' . $this->getIconHtml($selIcon) . $label . '</td>
                                                                <td class="c-descr" onclick="' . htmlspecialchars($onClickCell) . '">' . (empty($help) ? '' : $help) . '</td>
                                                </tr>';
                                        $c++;
                                }
                        }
                }
                // Remaining values (invalid):
                if (count($itemArray) && !$PA['fieldTSConfig']['disableNoMatchingValueElement'] && !$config['disableNoMatchingValueElement']) {
                        foreach ($itemArray as $theNoMatchValue => $temp) {
                                // Compile <checkboxes> tag:
                                array_unshift($tRows, '
                                                <tr class="c-invalidItem">
                                                        <td class="c-checkbox"><input type="checkbox"' . $this->insertDefStyle('check') . ' name="' . htmlspecialchars(($PA['itemFormElName'] . '[' . $c . ']')) . '" value="' . htmlspecialchars($theNoMatchValue) . '" checked="checked" onclick="' . htmlspecialchars($sOnChange) . '"' . $PA['onFocus'] . $disabled . ' /></td>
                                                        <td class="c-labelCell">' . htmlspecialchars(@sprintf($nMV_label, $theNoMatchValue), ENT_COMPAT, 'UTF-8', FALSE) . '</td><td>&nbsp;</td>
                                                </tr>');
                                $c++;
                        }
                }
                // Add an empty hidden field which will send a blank value if all items are unselected.
                $item .= '<input type="hidden" class="select-checkbox" name="' . htmlspecialchars($PA['itemFormElName']) . '" value="" />';
                // Remaining checkboxes will get their set-all link:
                if (count($setAll)) {
                        $tableHead = '<thead>
                                        <tr class="c-header-checkbox-controls t3-row-header">
                                                <td class="c-checkbox">
                                                <input type="checkbox" class="checkbox" onclick="if (checked) {' . htmlspecialchars((implode('', $setAll) . '} else {' . implode('', $unSetAll) . '}')) . '">
                                                </td>
                                                <td colspan="2">
                                                </td>
                                        </tr></thead>';
                }
                // Implode rows in table:
                $item .= '
                        <table border="0" cellpadding="0" cellspacing="0" class="typo3-TCEforms-select-checkbox">' . $tableHead . '<tbody>' . implode('', $tRows) . '</tbody>
                        </table>
                        ';
                // Add revert icon
                if (is_array($restoreCmd)) {
                        $item .= '<a href="#" onclick="' . implode('', $restoreCmd) . ' return false;' . '">' . IconUtility::getSpriteIcon('actions-edit-undo', array('title' => htmlspecialchars($this->getLL('l_revertSelection')))) . '</a>';
                }
                return $item;
        }

        /**
         * Creates a selectorbox list (renderMode = "singlebox")
         * (Render function for getSingleField_typeSelect())
         *
         * @param string $table See getSingleField_typeSelect()
         * @param string $field See getSingleField_typeSelect()
         * @param array $row See getSingleField_typeSelect()
         * @param array $PA See getSingleField_typeSelect()
         * @param array $config (Redundant) content of $PA['fieldConf']['config'] (for convenience)
         * @param array $selItems Items available for selection
         * @param string $nMV_label Label for no-matching-value
         * @return string The HTML code for the item
         * @see getSingleField_typeSelect()
         * @todo Define visibility
         */
        public function getSingleField_typeSelect_singlebox($table, $field, $row, &$PA, $config, $selItems, $nMV_label) {
                // Get values in an array (and make unique, which is fine because there can be no duplicates anyway):
                $itemArray = array_flip($this->extractValuesOnlyFromValueLabelList($PA['itemFormElValue']));
                $item = '';
                $disabled = '';
                if ($this->renderReadonly || $config['readOnly']) {
                        $disabled = ' disabled="disabled"';
                }
                // Traverse the Array of selector box items:
                $opt = array();
                // Used to accumulate the JS needed to restore the original selection.
                $restoreCmd = array();
                $c = 0;
                foreach ($selItems as $p) {
                        // Selected or not by default:
                        $sM = '';
                        if (isset($itemArray[$p[1]])) {
                                $sM = ' selected="selected"';
                                $restoreCmd[] = $this->elName(($PA['itemFormElName'] . '[]')) . '.options[' . $c . '].selected=1;';
                                unset($itemArray[$p[1]]);
                        }
                        // Non-selectable element:
                        $nonSel = '';
                        if ((string) $p[1] === '--div--') {
                                $nonSel = ' onclick="this.selected=0;" class="c-divider"';
                        }
                        // Icon style for option tag:
                        if ($config['iconsInOptionTags']) {
                                $styleAttrValue = $this->optionTagStyle($p[2]);
                        }
                        // Compile <option> tag:
                        $opt[] = '<option value="' . htmlspecialchars($p[1]) . '"' . $sM . $nonSel . ($styleAttrValue ? ' style="' . htmlspecialchars($styleAttrValue) . '"' : '') . '>' . htmlspecialchars($p[0], ENT_COMPAT, 'UTF-8', FALSE) . '</option>';
                        $c++;
                }
                // Remaining values:
                if (count($itemArray) && !$PA['fieldTSConfig']['disableNoMatchingValueElement'] && !$config['disableNoMatchingValueElement']) {
                        foreach ($itemArray as $theNoMatchValue => $temp) {
                                // Compile <option> tag:
                                array_unshift($opt, '<option value="' . htmlspecialchars($theNoMatchValue) . '" selected="selected">' . htmlspecialchars(@sprintf($nMV_label, $theNoMatchValue), ENT_COMPAT, 'UTF-8', FALSE) . '</option>');
                        }
                }
                // Compile selector box:
                $sOnChange = implode('', $PA['fieldChangeFunc']);
                $selector_itemListStyle = isset($config['itemListStyle']) ? ' style="' . htmlspecialchars($config['itemListStyle']) . '"' : ' style="' . $this->defaultMultipleSelectorStyle . '"';
                $size = (int)$config['size'];
                $cssPrefix = $size === 1 ? 'tceforms-select' : 'tceforms-multiselect';
                $size = $config['autoSizeMax'] ? MathUtility::forceIntegerInRange(count($selItems) + 1, MathUtility::forceIntegerInRange($size, 1), $config['autoSizeMax']) : $size;
                $selectBox = '<select id="' . uniqid($cssPrefix) . '" name="' . $PA['itemFormElName'] . '[]"' . $this->insertDefStyle('select', $cssPrefix) . ($size ? ' size="' . $size . '"' : '') . ' multiple="multiple" onchange="' . htmlspecialchars($sOnChange) . '"' . $PA['onFocus'] . $selector_itemListStyle . $disabled . '>
                                                ' . implode('
                                                ', $opt) . '
                                        </select>';
                // Add an empty hidden field which will send a blank value if all items are unselected.
                if (!$disabled) {
                        $item .= '<input type="hidden" name="' . htmlspecialchars($PA['itemFormElName']) . '" value="" />';
                }
                // Put it all into a table:
                $item .= '
                        <table border="0" cellspacing="0" cellpadding="0" width="1" class="typo3-TCEforms-select-singlebox">
                                <tr>
                                        <td>
                                        ' . $selectBox . '
                                        <br/>
                                        <em>' . htmlspecialchars($this->getLL('l_holdDownCTRL')) . '</em>
                                        </td>
                                        <td valign="top">
                                                <a href="#" onclick="' . htmlspecialchars(($this->elName(($PA['itemFormElName'] . '[]')) . '.selectedIndex=-1;' . implode('', $restoreCmd) . ' return false;')) . '" title="' . htmlspecialchars($this->getLL('l_revertSelection')) . '">' . IconUtility::getSpriteIcon('actions-edit-undo') . '</a>
                                        </td>
                                </tr>
                        </table>
                                ';
                return $item;
        }

        /**
         * Creates a multiple-selector box (two boxes, side-by-side)
         * (Render function for getSingleField_typeSelect())
         *
         * @param string $table See getSingleField_typeSelect()
         * @param string $field See getSingleField_typeSelect()
         * @param array $row See getSingleField_typeSelect()
         * @param array $PA See getSingleField_typeSelect()
         * @param array $config (Redundant) content of $PA['fieldConf']['config'] (for convenience)
         * @param array $selItems Items available for selection
         * @param string $nMV_label Label for no-matching-value
         * @return string The HTML code for the item
         * @see getSingleField_typeSelect()
         * @todo Define visibility
         */
        public function getSingleField_typeSelect_multiple($table, $field, $row, &$PA, $config, $selItems, $nMV_label) {
                $item = '';
                $disabled = '';
                if ($this->renderReadonly || $config['readOnly']) {
                        $disabled = ' disabled="disabled"';
                }
                // Setting this hidden field (as a flag that JavaScript can read out)
                if (!$disabled) {
                        $item .= '<input type="hidden" name="' . $PA['itemFormElName'] . '_mul" value="' . ($config['multiple'] ? 1 : 0) . '" />';
                }
                // Set max and min items:
                $maxitems = MathUtility::forceIntegerInRange($config['maxitems'], 0);
                if (!$maxitems) {
                        $maxitems = 100000;
                }
                $minitems = MathUtility::forceIntegerInRange($config['minitems'], 0);
                // Register the required number of elements:
                $this->registerRequiredProperty('range', $PA['itemFormElName'], array($minitems, $maxitems, 'imgName' => $table . '_' . $row['uid'] . '_' . $field));
                // Get "removeItems":
                $removeItems = GeneralUtility::trimExplode(',', $PA['fieldTSConfig']['removeItems'], TRUE);
                // Get the array with selected items:
                $itemArray = GeneralUtility::trimExplode(',', $PA['itemFormElValue'], TRUE);

                // Possibly filter some items:
                $itemArray = GeneralUtility::keepItemsInArray(
                        $itemArray,
                        $PA['fieldTSConfig']['keepItems'],
                        function ($value) {
                                $parts = explode('|', $value, 2);
                                return rawurldecode($parts[0]);
                        }
                );

                // Perform modification of the selected items array:
                foreach ($itemArray as $tk => $tv) {
                        $tvP = explode('|', $tv, 2);
                        $evalValue = $tvP[0];
                        $isRemoved = in_array($evalValue, $removeItems) || $config['form_type'] == 'select' && $config['authMode'] && !$this->getBackendUserAuthentication()->checkAuthMode($table, $field, $evalValue, $config['authMode']);
                        if ($isRemoved && !$PA['fieldTSConfig']['disableNoMatchingValueElement'] && !$config['disableNoMatchingValueElement']) {
                                $tvP[1] = rawurlencode(@sprintf($nMV_label, $evalValue));
                        } elseif (isset($PA['fieldTSConfig']['altLabels.'][$evalValue])) {
                                $tvP[1] = rawurlencode($this->sL($PA['fieldTSConfig']['altLabels.'][$evalValue]));
                        }
                        if ($tvP[1] == '') {
                                // Case: flexform, default values supplied, no label provided (bug #9795)
                                foreach ($selItems as $selItem) {
                                        if ($selItem[1] == $tvP[0]) {
                                                $tvP[1] = html_entity_decode($selItem[0]);
                                                break;
                                        }
                                }
                        }
                        $itemArray[$tk] = implode('|', $tvP);
                }
                $itemsToSelect = '';
                $filterTextfield = '';
                $filterSelectbox = '';
                if (!$disabled) {
                        // Create option tags:
                        $opt = array();
                        $styleAttrValue = '';
                        foreach ($selItems as $p) {
                                if ($config['iconsInOptionTags']) {
                                        $styleAttrValue = $this->optionTagStyle($p[2]);
                                }
                                $opt[] = '<option value="' . htmlspecialchars($p[1]) . '"' . ($styleAttrValue ? ' style="' . htmlspecialchars($styleAttrValue) . '"' : '') . ' title="' . $p[0] . '">' . $p[0] . '</option>';
                        }
                        // Put together the selector box:
                        $selector_itemListStyle = isset($config['itemListStyle']) ? ' style="' . htmlspecialchars($config['itemListStyle']) . '"' : ' style="' . $this->defaultMultipleSelectorStyle . '"';
                        $size = (int)$config['size'];
                        $size = $config['autoSizeMax'] ? MathUtility::forceIntegerInRange(count($itemArray) + 1, MathUtility::forceIntegerInRange($size, 1), $config['autoSizeMax']) : $size;
                        $sOnChange = implode('', $PA['fieldChangeFunc']);

                        $multiSelectId = uniqid('tceforms-multiselect-');
                        $itemsToSelect = '
                                <select data-relatedfieldname="' . htmlspecialchars($PA['itemFormElName']) . '" data-exclusivevalues="' . htmlspecialchars($config['exclusiveKeys']) . '" id="' . $multiSelectId . '" name="' . $PA['itemFormElName'] . '_sel"' . $this->insertDefStyle('select', 'tceforms-multiselect tceforms-itemstoselect t3-form-select-itemstoselect') . ($size ? ' size="' . $size . '"' : '') . ' onchange="' . htmlspecialchars($sOnChange) . '"' . $PA['onFocus'] . $selector_itemListStyle . '>
                                        ' . implode('
                                        ', $opt) . '
                                </select>';

                        if ($config['enableMultiSelectFilterTextfield'] || $config['multiSelectFilterItems']) {
                                $this->multiSelectFilterCount++;
                                $jsSelectBoxFilterName = str_replace(' ', '', ucwords(str_replace('-', ' ', GeneralUtility::strtolower($multiSelectId))));
                                $this->additionalJS_post[] = '
                                        var '. $jsSelectBoxFilterName . ' = new TCEForms.SelectBoxFilter("' . $multiSelectId . '");
                                ';
                        }

                        if ($config['enableMultiSelectFilterTextfield']) {
                                // add input field for filter
                                $filterTextfield = '<input class="typo3-TCEforms-suggest-search typo3-TCEforms-multiselect-filter" id="' . $multiSelectId . '_filtertextfield" value="" style="width: 104px;" />';
                        }

                        if (isset($config['multiSelectFilterItems']) && is_array($config['multiSelectFilterItems']) && count($config['multiSelectFilterItems']) > 1) {
                                $filterDropDownOptions = array();
                                foreach ($config['multiSelectFilterItems'] as $optionElement) {
                                        $filterDropDownOptions[] = '<option value="' . htmlspecialchars($this->sL($optionElement[0])) . '">' . htmlspecialchars((isset($optionElement[1]) && $optionElement[1] != '') ? $this->sL($optionElement[1]) : $this->sL($optionElement[0])) . '</option>';
                                }
                                $filterSelectbox = '
                                        <select id="' . $multiSelectId . '_filterdropdown">
                                                ' . implode('
                                                ', $filterDropDownOptions) . '
                                        </select>';
                        }
                }
                // Pass to "dbFileIcons" function:
                $params = array(
                        'size' => $size,
                        'autoSizeMax' => MathUtility::forceIntegerInRange($config['autoSizeMax'], 0),
                        'style' => isset($config['selectedListStyle']) ? ' style="' . htmlspecialchars($config['selectedListStyle']) . '"' : ' style="' . $this->defaultMultipleSelectorStyle . '"',
                        'dontShowMoveIcons' => $maxitems <= 1,
                        'maxitems' => $maxitems,
                        'info' => '',
                        'headers' => array(
                                'selector' => $this->getLL('l_selected') . ':<br />',
                                'items' => $this->getLL('l_items') . ': ' . $filterSelectbox . $filterTextfield . '<br />'
                        ),
                        'noBrowser' => 1,
                        'thumbnails' => $itemsToSelect,
                        'readOnly' => $disabled
                );
                $item .= $this->dbFileIcons($PA['itemFormElName'], '', '', $itemArray, '', $params, $PA['onFocus']);
                return $item;
        }

        /**
         * Generation of TCEform elements of the type "group"
         * This will render a selectorbox into which elements from either the file system or database can be inserted. Relations.
         *
         * @param string $table The table name of the record
         * @param string $field The field name which this element is supposed to edit
         * @param array $row The record data array where the value(s) for the field can be found
         * @param array $PA An array with additional configuration options.
         * @return string The HTML code for the TCEform field
         * @todo Define visibility
         */
        public function getSingleField_typeGroup($table, $field, $row, &$PA) {
                // Init:
                $config = $PA['fieldConf']['config'];
                $show_thumbs = $config['show_thumbs'];
                $size = isset($config['size']) ? (int)$config['size'] : 5;
                $maxitems = MathUtility::forceIntegerInRange($config['maxitems'], 1);
                $minitems = MathUtility::forceIntegerInRange($config['minitems'], 0);
                $allowed = trim($config['allowed']);
                $disallowed = trim($config['disallowed']);
                $item = '';
                $disabled = '';
                if ($this->renderReadonly || $config['readOnly']) {
                        $disabled = ' disabled="disabled"';
                }
                $item .= '<input type="hidden" name="' . $PA['itemFormElName'] . '_mul" value="' . ($config['multiple'] ? 1 : 0) . '"' . $disabled . ' />';
                $this->registerRequiredProperty('range', $PA['itemFormElName'], array($minitems, $maxitems, 'imgName' => $table . '_' . $row['uid'] . '_' . $field));
                $info = '';
                // "Extra" configuration; Returns configuration for the field based on settings found in the "types" fieldlist. See http://typo3.org/documentation/document-library/doc_core_api/Wizards_Configuratio/.
                $specConf = $this->getSpecConfFromString($PA['extra'], $PA['fieldConf']['defaultExtras']);
                $PA['itemFormElID_file'] = $PA['itemFormElID'] . '_files';
                // whether the list and delete controls should be disabled
                $noList = isset($config['disable_controls']) && GeneralUtility::inList($config['disable_controls'], 'list');
                $noDelete = isset($config['disable_controls']) && GeneralUtility::inList($config['disable_controls'], 'delete');
                // if maxitems==1 then automatically replace the current item (in list and file selector)
                if ($maxitems === 1) {
                        $this->additionalJS_post[] = 'TBE_EDITOR.clearBeforeSettingFormValueFromBrowseWin[\'' . $PA['itemFormElName'] . '\'] = {
                                        itemFormElID_file: \'' . $PA['itemFormElID_file'] . '\'
                                }';
                        $PA['fieldChangeFunc']['TBE_EDITOR_fieldChanged'] = 'setFormValueManipulate(\'' . $PA['itemFormElName'] . '\', \'Remove\'); ' . $PA['fieldChangeFunc']['TBE_EDITOR_fieldChanged'];
                } elseif ($noList) {
                        // If the list controls have been removed and the maximum number is reached, remove the first entry to avoid "write once" field
                        $PA['fieldChangeFunc']['TBE_EDITOR_fieldChanged'] = 'setFormValueManipulate(\'' . $PA['itemFormElName'] . '\', \'RemoveFirstIfFull\', \'' . $maxitems . '\'); ' . $PA['fieldChangeFunc']['TBE_EDITOR_fieldChanged'];
                }
                // Acting according to either "file" or "db" type:
                switch ((string) $config['internal_type']) {
                case 'file_reference':
                        $config['uploadfolder'] = '';
                        // Fall through
                case 'file':
                        // Creating string showing allowed types:
                        $tempFT = GeneralUtility::trimExplode(',', $allowed, TRUE);
                        if (!count($tempFT)) {
                                $info .= '*';
                        }
                        foreach ($tempFT as $ext) {
                                if ($ext) {
                                        $info .= strtoupper($ext) . ' ';