Documentation TYPO3 par Ameos

Disponible dans d'autres versions de TYPO3 -> 3.7.0  3.8.1  4.0.0  4.0.1  4.1.0   <- Available in other TYPO3 versions

class.t3lib_tceforms.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2006 Kasper Skaarhoj (kasperYYYY@typo3.com)
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project is
*  free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*  A copy is found in the textfile GPL.txt and important notices to the license
*  from the author is found in LICENSE.txt distributed with these scripts.
*
*
*  This script is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/
require_once(PATH_t3lib.'class.t3lib_diff.php');
require_once(PATH_t3lib.'class.t3lib_tceforms_inline.php');



class t3lib_TCEforms    {

                // variables not commented yet.... (do so...)
        var $palFieldArr = array();
        var $disableWizards = 0;
        var $isPalettedoc = 0;
        var $paletteMargin = 1;
        var $defStyle = ''; // 'font-family:Verdana;font-size:10px;';
        var $cachedTSconfig = array();
        var $cachedTSconfig_fieldLevel = array();
        var $cachedLanguageFlag = array();
        var $cachedAdditionalPreviewLanguages = NULL;
        var $transformedRow = array();
        var $extJSCODE = '';
        var $printNeededJS = array();
        var $hiddenFieldAccum=array();
        var $TBE_EDITOR_fieldChanged_func='';
        var $loadMD5_JS=1;
        var $prevBorderStyle='[nothing here...]';       // Something unique...
        var $allowUpload=0;                             // If set direct upload fields will be shown
        var $titleLen=15;                                       // @deprecated: $BE_USER->uc['titleLen'] but what is default??
        var $defaultLanguageData = array();     // Array where records in the default language is stored. (processed by transferdata)
        var $defaultLanguageData_diff = array();        // Array where records in the default language is stored (raw without any processing. used for making diff)
        var $additionalPreviewLanguageData = array();


                // EXTERNAL, static
        var $backPath='';                                       // Set this to the 'backPath' pointing back to the typo3 admin directory from the script where this form is displayed.
        var $returnUrl='';                                      // Alternative return URL path (default is t3lib_div::linkThisScript())
        var $doSaveFieldName='';                        // 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.
        var $palettesCollapsed=0;                       // 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.
        var $disableRTE=0;                                      // If set, the RTE is disabled (from form display, eg. by checkbox in the bottom of the page!)
        var $globalShowHelp=1;                          // If false, then all CSH will be disabled, regardless of settings in $this->edit_showFieldHelp
        var $localizationMode='';               // If true, the forms are rendering only localization relevant fields of the records.
        var $fieldOrder='';                                     // 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.
        var $doPrintPalette=1;                          // If set to false, palettes will NEVER be rendered.
        var $clipObj=FALSE;                                     // Set to initialized clipboard object; Then the element browser will offer a link to paste in records from clipboard.
        var $enableClickMenu=FALSE;                     // Enable click menu on reference icons.
        var $enableTabMenu = FALSE;                     // Enable Tab Menus. If set to true, the JavaScript content from template::getDynTabMenuJScode() must be included in the document.
        var $renderReadonly = FALSE;            // When enabled all fields are rendered non-editable.

        var $form_rowsToStylewidth = 9.58;      // Form field width compensation: Factor from NN4 form field widths to style-aware browsers (like NN6+ and MSIE, with the $CLIENT[FORMSTYLE] value set)
        var $form_largeComp = 1.33;                     // Form field width compensation: Compensation for large documents, doc-tab (editing)
        var $charsPerRow=40;                            // 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.
        var $maxTextareaWidth=48;                       // The maximum abstract value for textareas
        var $maxInputWidth=48;                          // The maximum abstract value for input fields
        var $defaultMultipleSelectorStyle='width:250px;';       // Default style for the selector boxes used for multiple items in "select" and "group" types.


                // INTERNAL, static
        var $prependFormFieldNames = 'data';            // The string to prepend formfield names with.
        var $prependCmdFieldNames = 'cmd';                      // The string to prepend commands for tcemain::process_cmdmap with.
        var $prependFormFieldNames_file = 'data_files';         // The string to prepend FILE form field names with.
        var $formName = 'editform';                                     // The name attribute of the form.
        var $allowOverrideMatrix = array();                     // Whitelist that allows TCA field configuration to be overridden by TSconfig, @see overrideFieldConf()



                // INTERNAL, dynamic
        var $perms_clause='';                                           // Set by readPerms()  (caching)
        var $perms_clause_set=0;                                        // Set by readPerms()  (caching-flag)
        var $edit_showFieldHelp='';                                     // Used to indicate the mode of CSH (Context Sensitive Help), whether it should be icons-only ('icon'), full description ('text') or not at all (blank).
        var $docLarge=0;                                                        // If set, the forms will be rendered a little wider, more precisely with a factor of $this->form_largeComp.
        var $clientInfo=array();                                        // Loaded with info about the browser when class is instantiated.
        var $RTEenabled=0;                                                      // True, if RTE is possible for the current user (based on result from BE_USER->isRTE())
        var $RTEenabled_notReasons='';                          // 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)
        var $RTEcounter = 0;                                            // Counter that is incremented before an RTE is created. Can be used for unique ids etc.

        var $colorScheme;                                                       // Contains current color scheme
        var $classScheme;                                                       // Contains current class scheme
        var $defColorScheme;                                            // Contains the default color scheme
        var $defClassScheme;                                            // Contains the default class scheme
        var $fieldStyle;                                                        // Contains field style values
        var $borderStyle;                                                       // Contains border style values.

        var $commentMessages=array();                           // An accumulation of messages from the class.

                // INTERNAL, templates
        var $totalWrap='<hr />|<hr />';                         // Total wrapping for the table rows.
        var $fieldTemplate='<b>###FIELD_NAME###</b><br />###FIELD_ITEM###<hr />';       // Field template
        var $sectionWrap='';                                            // Wrapping template code for a section
        var $palFieldTemplateHeader='';                         // Template for palette headers
        var $palFieldTemplate='';                                       // Template for palettes

                // INTERNAL, working memory
        var $excludeElements='';                                        // Set to the fields NOT to display, if any.
        var $palettesRendered=array();                          // During rendering of forms this will keep track of which palettes has already been rendered (so they are not rendered twice by mistake)
        var $hiddenFieldListArr = 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!
        var $requiredFields=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.
        var $requiredElements=array();                          // Used to register the min and max number of elements for selectorboxes where that apply (in the "group" type for instance)
        var $renderDepth=0;                                                     // Keeps track of the rendering depth of nested records.
        var $savedSchemes=array();                                      // Color scheme buffer.
        var $dynTabLevelStack = array();                        // holds tab dividers which were cascaded, required for RTE&IRRE

                // Internal, registers for user defined functions etc.
        var $additionalCode_pre = array();                      // Additional HTML code, printed before the form.
        var $additionalJS_pre = array();                        // Additional JavaScript, printed before the form
        var $additionalJS_post = array();                       // Additional JavaScript printed after the form
        var $additionalJS_submit = 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.

        var $inline;                                                            // Instance of t3lib_tceforms_inline
        var $hookObjectsMainFields = array();                   // Array containing hook class instances called once for a form
        var $hookObjectsSingleField = array();                  // Array containing hook class instances called for each field
        var $extraFormHeaders = array();                        // Rows gettings inserted into the alt_doc headers (when called from alt_doc.php)





        function t3lib_TCEforms()       {
                global $CLIENT, $TYPO3_CONF_VARS;

                $this->clientInfo = t3lib_div::clientInfo();

                $this->RTEenabled = $GLOBALS['BE_USER']->isRTE();
                if (!$this->RTEenabled) {
                        $this->RTEenabled_notReasons = implode(chr(10),$GLOBALS['BE_USER']->RTE_errors);
                        $this->commentMessages[] = 'RTE NOT ENABLED IN SYSTEM due to:'.chr(10).$this->RTEenabled_notReasons;
                }

                        // Default color+class scheme
                $this->defColorScheme = array(
                        $GLOBALS['SOBE']->doc->bgColor, // Background for the field AND palette
                        t3lib_div::modifyHTMLColorAll($GLOBALS['SOBE']->doc->bgColor,-20),      // Background for the field header
                        t3lib_div::modifyHTMLColorAll($GLOBALS['SOBE']->doc->bgColor,-10),      // Background for the palette field header
                        'black',        // Field header font color
                        '#666666'       // Palette field header font color
                );
                $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'),
                        'text' => array('cols', 'rows', 'wrap'),
                        'check' => array('cols', 'showIfRTE'),
                        'select' => array('size', 'autoSizeMax', 'maxitems', 'minitems'),
                        'group' => array('size', 'autoSizeMax', 'max_size', 'show_thumbs', 'maxitems', 'minitems'),
                        'inline' => array('appearance', 'foreign_label', 'foreign_selector', 'foreign_unique', 'maxitems', 'minitems', 'size', 'autoSizeMax', 'symmetric_label'),
                );

                $this->inline = t3lib_div::makeInstance('t3lib_TCEforms_inline');

                        // Prepare user defined objects (if any) for hooks which extend this function:
                $this->hookObjectsMainFields = array();
                if (is_array ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tceforms.php']['getMainFieldsClass']))  {
                        foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tceforms.php']['getMainFieldsClass'] as $classRef)   {
                                $this->hookObjectsMainFields[] = &t3lib_div::getUserObj($classRef);
                        }
                }
                $this->hookObjectsSingleField = array();
                if (is_array ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tceforms.php']['getSingleFieldClass'])) {
                        foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tceforms.php']['getSingleFieldClass'] as $classRef)  {
                                $this->hookObjectsSingleField[] = &t3lib_div::getUserObj($classRef);
                        }
                }

        }

        function initDefaultBEmode()    {
                global $BE_USER;
                $this->prependFormFieldNames = 'data';
                $this->formName = 'editform';
                $this->setNewBEDesign();
                $this->docLarge = $BE_USER->uc['edit_wideDocument'] ? 1 : 0;
                $this->edit_showFieldHelp = $BE_USER->uc['edit_showFieldHelp'];

                $this->edit_docModuleUpload = $BE_USER->uc['edit_docModuleUpload'];
                $this->titleLen = $BE_USER->uc['titleLen'];             // @deprecated

                $this->inline->init($this);
        }

















        /*******************************************************
         *
         * Rendering the forms, fields etc
         *
         *******************************************************/

        function getSoloField($table,$row,$theFieldToReturn)    {
                global $TCA;

                if ($TCA[$table])       {
                        t3lib_div::loadTCA($table);
                        $typeNum = $this->getRTypeNum($table,$row);
                        if ($TCA[$table]['types'][$typeNum])    {
                                $itemList = $TCA[$table]['types'][$typeNum]['showitem'];
                                if ($itemList)  {
                                        $fields = t3lib_div::trimExplode(',',$itemList,1);
                                        $excludeElements = $this->excludeElements = $this->getExcludeElements($table,$row,$typeNum);

                                        reset($fields);
                                        while(list(,$fieldInfo)=each($fields))  {
                                                $parts = explode(';',$fieldInfo);

                                                $theField = trim($parts[0]);
                                                if (!in_array($theField,$excludeElements) && !strcmp($theField,$theFieldToReturn))      {
                                                        if ($TCA[$table]['columns'][$theField]) {
                                                                $sField = $this->getSingleField($table,$theField,$row,$parts[1],1,$parts[3],$parts[2]);
                                                                return $sField['ITEM'];
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        function getMainFields($table,$row,$depth=0)    {
                global $TCA, $TYPO3_CONF_VARS;

                $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 ($TCA[$table])       {

                                // Load the full TCA for the table.
                        t3lib_div::loadTCA($table);

                                // Load the description content for the table.
                        if ($this->edit_showFieldHelp || $this->doLoadTableDescr($table))       {
                                $GLOBALS['LANG']->loadSingleTableDescription($table);
                        }
                                // Get the current "type" value for the record.
                        $typeNum = $this->getRTypeNum($table,$row);

                                // Find the list of fields to display:
                        if ($TCA[$table]['types'][$typeNum])    {
                                $itemList = $TCA[$table]['types'][$typeNum]['showitem'];
                                if ($itemList)  {       // If such a list existed...
                                                // if TCEforms will render a tab menu in the next step, push the name to the tab stack
                                        if (strstr($itemList, '--div--') !== false && $this->enableTabMenu && $TCA[$table]['ctrl']['dividers2tabs']) {
                                                $tabIdentString = 'TCEforms:'.$table.':'.$row['uid'];
                                                $tabIdentStringMD5 = $GLOBALS['TBE_TEMPLATE']->getDynTabMenuId('TCEforms:'.$table.':'.$row['uid']);
                                                $this->dynTabLevelStack[$tabIdentStringMD5] = 1;
                                        }

                                                // Explode the field list and possibly rearrange the order of the fields, if configured for
                                        $fields = t3lib_div::trimExplode(',',$itemList,1);
                                        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));

                                                // 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 = t3lib_div::trimExplode('-',$parts[4]);
                                                if (strcmp($color_style_parts[0],''))   {
                                                        $this->setColorScheme($GLOBALS['TBE_STYLES']['colorschemes'][intval($color_style_parts[0])]);
                                                }
                                                if (strcmp($color_style_parts[1],''))   {
                                                        $this->fieldStyle = $GLOBALS['TBE_STYLES']['styleschemes'][intval($color_style_parts[1])];
                                                        if (!isset($this->fieldStyle))  $this->fieldStyle = $GLOBALS['TBE_STYLES']['styleschemes'][0];
                                                }
                                                if (strcmp($color_style_parts[2],''))   {
                                                        $this->wrapBorder($out_array[$out_sheet],$out_pointer);
                                                        $this->borderStyle = $GLOBALS['TBE_STYLES']['borderschemes'][intval($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 ($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 && $TCA[$table]['ctrl']['dividers2tabs'])      {
                                                                                $this->wrapBorder($out_array[$out_sheet],$out_pointer);
                                                                                $out_sheet++;
                                                                                        // remember what sheet we're currently in
                                                                                $this->dynTabLevelStack[$tabIdentStringMD5] = $out_sheet+1;
                                                                                $out_array[$out_sheet] = array();
                                                                                $out_array_meta[$out_sheet]['title'] = $this->sL($parts[1]);
                                                                        }
                                                                } else {        // Setting alternative title for "General" tab if "--div--" is the very first element.
                                                                        $out_array_meta[$out_sheet]['title'] = $this->sL($parts[1]);
                                                                }
                                                        } elseif($theField=='--palette--')      {
                                                                if ($parts[2] && !isset($this->palettesRendered[$this->renderDepth][$table][$parts[2]]))        {
                                                                                // render a 'header' if not collapsed
                                                                        if ($TCA[$table]['palettes'][$parts[2]]['canNotCollapse'] AND $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 = t3lib_div::trimExplode(',',$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=0;
                                        $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:
                if ($out_sheet>0)       {       // There were --div-- dividers around...

                                // Create parts array for the tab menu:
                        $parts = array();
                        foreach ($out_array as $idx => $sheetContent)   {
                                $parts[] = array(
                                        'label' => $out_array_meta[$idx]['title'],
                                        'content' => '<table border="0" cellspacing="0" cellpadding="0" width="100%">'.
                                                        implode('',$sheetContent).
                                                '</table>'
                                );
                        }

                                // unset the current level of tab menus
                        unset($this->dynTabLevelStack[$tabIdentStringMD5]);

                        return '
                                <tr>
                                        <td colspan="2">
                                        '.$this->getDynTabMenu($parts, $tabIdentString).'
                                        </td>
                                </tr>';
                } else {        // Only one, so just implode:
                        return implode('',$out_array[$out_sheet]);
                }
        }

        function getListedFields($table,$row,$list)     {
                global $TCA;

                t3lib_div::loadTCA($table);
                if ($this->edit_showFieldHelp || $this->doLoadTableDescr($table))       {
                        $GLOBALS['LANG']->loadSingleTableDescription($table);
                }

                $out = '';
                $types_fieldConfig = t3lib_BEfunc::getTCAtypes($table,$row,1);

                $editFieldList=array_unique(t3lib_div::trimExplode(',',$list,1));
                foreach($editFieldList as $theFieldC)   {
                        list($theField,$palFields) = split('\[|\]',$theFieldC);
                        $theField = trim($theField);
                        $palFields = trim($palFields);
                        if ($TCA[$table]['columns'][$theField]) {
                                $parts = t3lib_div::trimExplode(';',$types_fieldConfig[$theField]['origString']);
                                $sField = $this->getSingleField($table,$theField,$row,$parts[1],0,$parts[3],0); // Don't sent palette pointer - there are no options anyways for a field-list.
                                $out.= $sField;
                        } elseif($theField=='--div--')  {
                                $out.= $this->getDivider();
                        }
                        if ($palFields) {
                                $out.= $this->getPaletteFields($table,$row,'','',implode(',',t3lib_div::trimExplode('|',$palFields,1)));
                        }
                }

                return $out;
        }

        function getPaletteFields($table,$row,$palette,$header='',$itemList='',$collapsedHeader='')     {
                global $TCA;
                if (!$this->doPrintPalette)     return '';

                $out='';
                $palParts = array();
                t3lib_div::loadTCA($table);

                        // Getting excludeElements, if any.
                if (!is_array($this->excludeElements))  {
                        $this->excludeElements = $this->getExcludeElements($table,$row,$this->getRTypeNum($table,$row));
                }

                        // Render the palette TCEform elements.
                if ($TCA[$table] && (is_array($TCA[$table]['palettes'][$palette]) || $itemList))        {
                        $itemList = $itemList?$itemList:$TCA[$table]['palettes'][$palette]['showitem'];
                        if ($itemList)  {
                                $fields = t3lib_div::trimExplode(',',$itemList,1);
                                reset($fields);
                                while(list(,$fieldInfo)=each($fields))  {
                                        $parts = t3lib_div::trimExplode(';',$fieldInfo);
                                        $theField = $parts[0];

                                        if (!in_array($theField,$this->excludeElements) && $TCA[$table]['columns'][$theField])  {
                                                $this->palFieldArr[$palette][] = $theField;
                                                if ($this->isPalettesCollapsed($table,$palette))        {
                                                        $this->hiddenFieldListArr[] = $theField;
                                                }

                                                $part = $this->getSingleField($table,$theField,$row,$parts[1],1,'',$parts[2]);
                                                if (is_array($part))    {
                                                        $palParts[] = $part;
                                                }
                                        }
                                }
                        }
                }
                        // Put palette together if there are fields in it:
                if (count($palParts))   {
                        if ($header)    {
                                $out.= $this->intoTemplate(array(
                                                                'HEADER' => htmlspecialchars($header)
                                                        ),
                                                        $this->palFieldTemplateHeader
                                                );
                        }
                        $out.= $this->intoTemplate(array(
                                                        'PALETTE' => $this->printPalette($palParts)
                                                ),
                                                $this->palFieldTemplate
                                        );
                }
                        // If a palette is collapsed (not shown in form, but in top frame instead) AND a collapse header string is given, then make that string a link to activate the palette.
                if ($this->isPalettesCollapsed($table,$palette) && $collapsedHeader)    {
                        $pC = $this->intoTemplate(array(
                                                        'PALETTE' => $this->wrapOpenPalette('<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/options.gif','width="18" height="16"').' border="0" title="'.htmlspecialchars($this->getLL('l_moreOptions')).'" align="top" alt="" /><strong>'.$collapsedHeader.'</strong>',$table,$row,$palette),
                                                ),
                                                $this->palFieldTemplate
                                        );
                        $out.= $pC;
                }

                return $out;
        }

        function getSingleField($table,$field,$row,$altName='',$palette=0,$extra='',$pal=0)     {
                global $TCA,$BE_USER;

                        // 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;

                        // Make sure to load full $TCA array for the table:
                t3lib_div::loadTCA($table);

                        // Get the TCA configuration for the current field:
                $PA['fieldConf'] = $TCA[$table]['columns'][$field];
                $PA['fieldConf']['config']['form_type'] = $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']);

                        // Now, check if this field is configured and editable (according to excludefields + other configuration)
                if (    is_array($PA['fieldConf']) &&
                                !$skipThisField &&
                                (!$PA['fieldConf']['exclude'] || $BE_USER->check('non_exclude_fields',$table.':'.$field)) &&
                                $PA['fieldConf']['config']['form_type']!='passthrough' &&
                                ($this->RTEenabled || !$PA['fieldConf']['config']['showIfRTE']) &&
                                (!$PA['fieldConf']['displayCond'] || $this->isDisplayCondition($PA['fieldConf']['displayCond'],$row)) &&
                                (!$TCA[$table]['ctrl']['languageField'] || $PA['fieldConf']['l10n_display'] || strcmp($PA['fieldConf']['l10n_mode'],'exclude') || $row[$TCA[$table]['ctrl']['languageField']]<=0) &&
                                (!$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
                                $PA['itemFormElName_file']=$this->prependFormFieldNames_file.'['.$table.']['.$row['uid'].']['.$field.']';       // Form field name, in case of file uploads
                                $PA['itemFormElValue']=$row[$field];            // The value to show in the form 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'] AND t3lib_div::inList($PA['fieldConf']['l10n_display'], 'defaultAsReadonly') AND $row[$TCA[$table]['ctrl']['languageField']]) {
                                        $PA['fieldConf']['config']['readOnly'] =  true;
                                        $PA['itemFormElValue'] = $this->defaultLanguageData[$table.':'.$row['uid']][$field];
                                }

                                        // 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 (
                                        ($TCA[$table]['ctrl']['type'] && !strcmp($field,$TCA[$table]['ctrl']['type'])) ||
                                        ($TCA[$table]['ctrl']['requestUpdate'] && t3lib_div::inList($TCA[$table]['ctrl']['requestUpdate'],$field))) {
                                        if($GLOBALS['BE_USER']->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'])    {
                                                if ($PA['pal'] && $this->isPalettesCollapsed($table,$PA['pal']))        {
                                                        list($thePalIcon,$palJSfunc) = $this->wrapOpenPalette('<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/options.gif','width="18" height="16"').' border="0" title="'.htmlspecialchars($this->getLL('l_moreOptions')).'" alt="" />',$table,$row,$PA['pal'],1);
                                                } else {
                                                        $thePalIcon = '';
                                                        $palJSfunc = '';
                                                }
                                        }
                                                // onFocus attribute to add to the field:
                                        $PA['onFocus'] = ($palJSfunc && !$BE_USER->uc['dontShowPalettesOnFocusInAB']) ? ' onfocus="'.htmlspecialchars($palJSfunc).'"' : '';

                                                // Find item
                                        $item='';
                                        $PA['label'] = $PA['altName'] ? $PA['altName'] : $PA['fieldConf']['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)) {
                                                $PA['fieldChangeFunc']['inline'] = "inline.handleChangedField('".$PA['itemFormElName']."','".$this->inline->inlineNames['object']."[$table][".$row['uid']."]');";
                                        }

                                                // 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'] && (t3lib_div::inList($PA['fieldConf']['l10n_display'], 'hideDiff') || t3lib_div::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
                                        $PA['label'] = t3lib_div::deHSCentities(htmlspecialchars($PA['label']));
                                        if (t3lib_div::testInt($row['uid']) && $PA['fieldTSConfig']['linkTitleToSelf']) {
                                                $lTTS_url = $this->backPath.'alt_doc.php?edit['.$table.']['.$row['uid'].']=edit&columnsOnly='.$field.
                                                                        ($PA['fieldTSConfig']['linkTitleToSelf.']['returnUrl']?'&returnUrl='.rawurlencode($this->thisReturnUrl()):'');
                                                $PA['label'] = '<a href="'.htmlspecialchars($lTTS_url).'">'.$PA['label'].'</a>';
                                        }

                                                // Create output value:
                                        if ($PA['fieldConf']['config']['form_type']=='user' && $PA['fieldConf']['config']['noTableWrapping'])   {
                                                $out = $item;
                                        } elseif ($PA['palette'])       {
                                                        // Array:
                                                $out=array(
                                                        'NAME'=>$PA['label'],
                                                        'ID'=>$row['uid'],
                                                        'FIELD'=>$field,
                                                        'TABLE'=>$table,
                                                        'ITEM'=>$item,
                                                        'HELP_ICON' => $this->helpTextIcon($table,$field,1)
                                                );
                                                $out = $this->addUserTemplateMarkers($out,$table,$field,$row,$PA);
                                        } else {
                                                        // String:
                                                $out=array(
                                                        'NAME'=>$PA['label'],
                                                        'ITEM'=>$item,
                                                        'TABLE'=>$table,
                                                        'ID'=>$row['uid'],
                                                        'HELP_ICON'=>$this->helpTextIcon($table,$field),
                                                        'HELP_TEXT'=>$this->helpText($table,$field),
                                                        'PAL_LINK_ICON'=>$thePalIcon,
                                                        'FIELD'=>$field
                                                );
                                                $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;
        }

        function getSingleField_SW($table,$field,$row,&$PA)     {
                $PA['fieldConf']['config']['form_type'] = $PA['fieldConf']['config']['form_type'] ? $PA['fieldConf']['config']['form_type'] : $PA['fieldConf']['config']['type'];       // Using "form_type" locally in this script

                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);
                        break;
                }

                return $item;
        }



















        /**********************************************************
         *
         * Rendering of each TCEform field type
         *
         ************************************************************/

        function getSingleField_typeInput($table,$field,$row,&$PA)      {
                // typo3FormFieldSet(theField, evallist, is_in, checkbox, checkboxValue)
                // typo3FormFieldGet(theField, evallist, is_in, checkbox, checkboxValue, checkbox_off)

                $config = $PA['fieldConf']['config'];

#               $specConf = $this->getSpecConfForField($table,$row,$field);
                $specConf = $this->getSpecConfFromString($PA['extra'], $PA['fieldConf']['defaultExtras']);
                $size = t3lib_div::intInRange($config['size']?$config['size']:30,5,$this->maxInputWidth);
                $evalList = t3lib_div::trimExplode(',',$config['eval'],1);


                if($this->renderReadonly || $config['readOnly'])  {
                        $itemFormElValue = $PA['itemFormElValue'];
                        if (in_array('date',$evalList)) {
                                $config['format'] = 'date';
                        } elseif (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);
                }

                if (in_array('required',$evalList))     {
                        $this->requiredFields[$table.'_'.$row['uid'].'_'.$field]=$PA['itemFormElName'];
                }

                $paramsList = "'".$PA['itemFormElName']."','".implode(',',$evalList)."','".trim($config['is_in'])."',".(isset($config['checkbox'])?1:0).",'".$config['checkbox']."'";
                if (isset($config['checkbox'])) {
                                // Setting default "click-checkbox" values for eval types "date" and "datetime":
                        $thisMidnight = mktime(0,0,0);
                        $checkSetValue = in_array('date',$evalList) ? $thisMidnight : '';
                        $checkSetValue = in_array('datetime',$evalList) ? time() : $checkSetValue;

                        $cOnClick = 'typo3form.fieldGet('.$paramsList.',1,\''.$checkSetValue.'\');'.implode('',$PA['fieldChangeFunc']);
                        $item.='<input type="checkbox"'.$this->insertDefStyle('check').' name="'.$PA['itemFormElName'].'_cb" onclick="'.htmlspecialchars($cOnClick).'" />';
                }

                $PA['fieldChangeFunc'] = array_merge(array('typo3form.fieldGet'=>'typo3form.fieldGet('.$paramsList.');'), $PA['fieldChangeFunc']);
                $mLgd = ($config['max']?$config['max']:256);
                $iOnChange = implode('',$PA['fieldChangeFunc']);
                $item.='<input type="text" name="'.$PA['itemFormElName'].'_hr" value=""'.$this->formWidth($size).' 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.
                $this->extJSCODE.='typo3form.fieldSet('.$paramsList.');';

                        // going through all custom evaluations configured for this field
                foreach ($evalList as $evalData) {
                        if (substr($evalData, 0, 3) == 'tx_')   {
                                $evalObj = t3lib_div::getUserObj($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tce']['formevals'][$evalData].':&'.$evalData);
                                if(is_object($evalObj) && method_exists($evalObj, 'returnFieldJS'))     {
                                        $this->extJSCODE .= "\n\nfunction ".$evalData."(value) {\n".$evalObj->returnFieldJS()."\n}\n";
                                }
                        }
                }

                        // 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;
        }

        function getSingleField_typeText($table,$field,$row,&$PA)       {

                        // Init config:
                $config = $PA['fieldConf']['config'];

                if($this->renderReadonly || $config['readOnly'])  {
                        return $this->getSingleField_typeNone_render($config, $PA['itemFormElValue']);
                }

                        // Setting columns number:
                $cols = t3lib_div::intInRange($config['cols'] ? $config['cols'] : 30, 5, $this->maxTextareaWidth);

                        // Setting number of rows:
                $origRows = $rows = t3lib_div::intInRange($config['rows'] ? $config['rows'] : 5, 1, 20);
                if (strlen($PA['itemFormElValue']) > $this->charsPerRow*2)      {
                        $cols = $this->maxTextareaWidth;
                        $rows = t3lib_div::intInRange(round(strlen($PA['itemFormElValue'])/$this->charsPerRow), count(explode(chr(10),$PA['itemFormElValue'])), 20);
                        if ($rows<$origRows)    $rows = $origRows;
                }

                        // Init RTE vars:
                $RTEwasLoaded = 0;                              // Set true, if the RTE is loaded; If not a normal textarea is shown.
                $RTEwouldHaveBeenLoaded = 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...

                        // "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 = t3lib_BEfunc::getSpecConfParametersFromArray($specConf['rte_transform']['parameters']);
                        if (isset($specConf['richtext']) && (!$p['flag'] || !$row[$p['flag']])) {       // If the field is configured for RTE and if any flag-field is not set to disable it.
                                t3lib_BEfunc::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 = $GLOBALS['BE_USER']->getTSConfig('RTE',t3lib_BEfunc::getPagesTSconfig($tscPID));
                                        $RTEtypeVal = t3lib_BEfunc::getTCAtypeValue($table,$row);
                                        $thisConfig = t3lib_BEfunc::RTEsetup($RTEsetup['properties'],$table,$field,$RTEtypeVal);

                                        if (!$thisConfig['disabled'])   {
                                                if (!$this->disableRTE) {
                                                        $this->RTEcounter++;

                                                                // Find alternative relative path for RTE images/links:
                                                        $eFile = t3lib_parsehtml_proc::evalWriteFile($specConf['static_write'], $row);
                                                        $RTErelPath = is_array($eFile) ? dirname($eFile['relEditFile']) : '';

                                                                // Get RTE object, draw form and set flag:
                                                        $RTEobj = &t3lib_BEfunc::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;