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_transferdata.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_loaddbgroup.php');
require_once (PATH_t3lib.'class.t3lib_loadmodules.php');
require_once (PATH_t3lib.'class.t3lib_parsehtml_proc.php');
require_once (PATH_t3lib.'class.t3lib_flexformtools.php');












class t3lib_transferData {
                // External, static:
        var $lockRecords=0;                                     // If set, the records requested are locked.
        var $disableRTE=0;                                      // Is set externally if RTE is disabled.
        var $prevPageID = '';                           // If the pid in the command is 'prev' then $prevPageID is used as pid for the record. This is used to attach new records to other previous records eg. new pages.
        var $defVals=array();                                           // Can be set with an array of default values for tables. First key is table name, second level keys are field names. Originally this was a GLOBAL array used internally.
        var $addRawData = FALSE;                        // If set, the processed data is overlaid the raw record.

                // Internal, dynamic
        var $regTableItems = Array();           // Used to register, which items are already loaded!!
        var $regTableItems_data = Array();      // This stores the record data of the loaded records
        var $loadModules='';                            // Contains loadModules object, if used. (for reuse internally)










        /***********************************************
         *
         * Getting record content, ready for display in TCEforms
         *
         ***********************************************/

        function fetchRecord($table,$idList,$operation) {
                global $TCA;

                if ((string)$idList == 'prev')  {$idList = $this->prevPageID;}

                if ($TCA[$table])       {
                        t3lib_div::loadTCA($table);

                                // For each ID value (integer) we
                        $ids = t3lib_div::trimExplode(',',$idList,1);
                        foreach($ids as $id)    {
                                if (strcmp($id,''))     {       // If ID is not blank:

                                                // For new records to be created, find default values:
                                        if ($operation=='new')  {

                                                        // Default values:
                                                $newRow = Array();      // Used to store default values as found here:

                                                        // Default values as set in userTS:
                                                $TCAdefaultOverride = $GLOBALS['BE_USER']->getTSConfigProp('TCAdefaults');
                                                if (is_array($TCAdefaultOverride[$table.'.']))  {
                                                        foreach($TCAdefaultOverride[$table.'.'] as $theF => $theV)      {
                                                                if (isset($TCA[$table]['columns'][$theF]))      {
                                                                        $newRow[$theF]=$theV;
                                                                }
                                                        }
                                                }

                                                        // Default values as submitted:
                                                if (is_array($this->defVals[$table]))   {
                                                        foreach($this->defVals[$table] as $theF => $theV)       {
                                                                if (isset($TCA[$table]['columns'][$theF]))      {
                                                                        $newRow[$theF]=$theV;
                                                                }
                                                        }
                                                }

                                                        // Fetch default values if a previous record exists
                                                if ($id<0 && $TCA[$table]['ctrl']['useColumnsForDefaultValues'])        {
                                                                // Fetches the previous record:
                                                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', $table, 'uid='.abs($id).t3lib_BEfunc::deleteClause($table));
                                                        if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                                                                        // Gets the list of fields to copy from the previous record.
                                                                $fArr=t3lib_div::trimExplode(',',$TCA[$table]['ctrl']['useColumnsForDefaultValues'],1);
                                                                while(list(,$theF)=each($fArr)) {
                                                                        if (isset($TCA[$table]['columns'][$theF]))      {
                                                                                $newRow[$theF]=$row[$theF];
                                                                        }
                                                                }
                                                        }
                                                        $GLOBALS['TYPO3_DB']->sql_free_result($res);
                                                }

                                                        // Finally, call renderRecord:
                                                $this->renderRecord($table, uniqid('NEW'), $id, $newRow);
                                        } else {
                                                $id=intval($id);

                                                        // Fetch database values
                                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', $table, 'uid='.intval($id).t3lib_BEfunc::deleteClause($table));
                                                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                                                        t3lib_BEfunc::fixVersioningPid($table,$row);
                                                        $this->renderRecord($table, $id, $row['pid'], $row);
                                                        $contentTable = $GLOBALS['TYPO3_CONF_VARS']['SYS']['contentTable'];
                                                        $this->lockRecord($table, $id, $contentTable==$table?$row['pid']:0);    // Locking the pid if the table edited is the content table.
                                                }
                                                $GLOBALS['TYPO3_DB']->sql_free_result($res);
                                        }
                                }
                        }
                }
        }

        function renderRecord($table, $id, $pid, $row)  {
                global $TCA;

                        // Init:
                $uniqueItemRef = $table.'_'.$id;
                t3lib_div::loadTCA($table);

                        // Fetches the true PAGE TSconfig pid to use later, if needed. (Until now, only for the RTE, but later..., who knows?)
                list($tscPID)=t3lib_BEfunc::getTSCpid($table,$id,$pid);
                $TSconfig = t3lib_BEfunc::getTCEFORM_TSconfig($table,array_merge($row,array('uid'=>$id,'pid'=>$pid)));

                        // If the record has not already been loaded (in which case we DON'T do it again)...
                if (!$this->regTableItems[$uniqueItemRef])      {
                        $this->regTableItems[$uniqueItemRef] = 1;       // set "loaded" flag.

                                // If the table is pages, set the previous page id internally.
                        if ($table == 'pages')  {$this->prevPageID = $id;}

                        $this->regTableItems_data[$uniqueItemRef] = $this->renderRecordRaw($table, $id, $pid, $row, $TSconfig, $tscPID);

                                // Merges the processed array on-top of the raw one - this is done because some things in TCEforms may need access to other fields than those in the columns configuration!
                        if ($this->addRawData && is_array($row) && is_array($this->regTableItems_data[$uniqueItemRef])) {
                                $this->regTableItems_data[$uniqueItemRef] = array_merge($row, $this->regTableItems_data[$uniqueItemRef]);
                        }
                }
        }



        function renderRecordRaw($table, $id, $pid, $row, $TSconfig='', $tscPID=0)      {
                global $TCA;

                if(!is_array($TSconfig)) {
                        $TSconfig = array();
                }

                        // Create blank accumulation array:
                $totalRecordContent=array();

                        // Traverse the configured columns for the table (TCA):
                        // For each column configured, we will perform processing if needed based on the type (eg. for "group" and "select" types this is needed)
                t3lib_div::loadTCA($table);
                $copyOfColumns = $TCA[$table]['columns'];
                foreach($copyOfColumns as $field => $fieldConfig)       {
                                // Set $data variable for the field, either inputted value from $row - or if not found, the default value as defined in the "config" array
                        if (isset($row[$field]))        {
                                $data = $row[$field];
                        } else {
                                $data = $fieldConfig['config']['default'];
                        }

                        $data = $this->renderRecord_SW($data,$fieldConfig,$TSconfig,$table,$row,$field);

                                // Set the field in the accumulation array IF the $data variabel is set:
                        $totalRecordContent[$field] = isset($data) ? $data : '';
                }

                        // Further processing may apply for each field in the record depending on the settings in the "types" configuration (the list of fields to currently display for a record in TCEforms).
                        // For instance this could be processing instructions for the Rich Text Editor.
                $types_fieldConfig = t3lib_BEfunc::getTCAtypes($table,$totalRecordContent);
                if (is_array($types_fieldConfig))       {
                        $totalRecordContent = $this->renderRecord_typesProc($totalRecordContent,$types_fieldConfig,$tscPID,$table,$pid);
                }

                        // Register items, mostly for external use (overriding the regItem() function)
                foreach($totalRecordContent as $field => $data) {
                        $this->regItem($table,$id,$field,$data);
                }

                        // Finally, store the result:
                reset($totalRecordContent);

                return $totalRecordContent;

        }

        function renderRecord_SW($data,$fieldConfig,$TSconfig,$table,$row,$field)       {
                switch((string)$fieldConfig['config']['type'])  {
                        case 'group':
                                $data = $this->renderRecord_groupProc($data,$fieldConfig,$TSconfig,$table,$row,$field);
                        break;
                        case 'select':
                                $data = $this->renderRecord_selectProc($data,$fieldConfig,$TSconfig,$table,$row,$field);
                        break;
                        case 'flex':
                                $data = $this->renderRecord_flexProc($data,$fieldConfig,$TSconfig,$table,$row,$field);
                        break;
                        case 'inline':
                                $data = $this->renderRecord_inlineProc($data,$fieldConfig,$TSconfig,$table,$row,$field);
                        break;
                }

                return $data;
        }

        function renderRecord_groupProc($data,$fieldConfig,$TSconfig,$table,$row,$field)        {
                switch ($fieldConfig['config']['internal_type'])        {
                        case 'file':
                                        // Init array used to accumulate the files:
                                $dataAcc=array();

                                        // Now, load the files into the $dataAcc array, whether stored by MM or as a list of filenames:
                                if ($fieldConfig['config']['MM'])       {
                                        $loadDB = t3lib_div::makeInstance('t3lib_loadDBGroup');
                                        $loadDB->start('', 'files', $fieldConfig['config']['MM'], $row['uid']); // Setting dummy startup

                                        foreach($loadDB->itemArray as $value)   {
                                                if ($value['id'])       {
                                                        $dataAcc[]=rawurlencode($value['id']).'|'.rawurlencode($value['id']);
                                                }
                                        }
                                } else {
                                        $fileList = t3lib_div::trimExplode(',',$data,1);
                                        foreach($fileList as $value)    {
                                                if ($value)     {
                                                        $dataAcc[]=rawurlencode($value).'|'.rawurlencode($value);
                                                }
                                        }
                                }
                                        // Implode the accumulation array to a comma separated string:
                                $data = implode(',',$dataAcc);
                        break;
                        case 'db':
                                $loadDB = t3lib_div::makeInstance('t3lib_loadDBGroup');
                                $loadDB->start($data, $fieldConfig['config']['allowed'], $fieldConfig['config']['MM'], $row['uid'], $table, $fieldConfig['config']);
                                $loadDB->getFromDB();
                                $data = $loadDB->readyForInterface();
                        break;
                }

                return $data;
        }

        function renderRecord_selectProc($data,$fieldConfig,$TSconfig,$table,$row,$field)       {
                global $TCA;

                        // Initialize:
                $elements = t3lib_div::trimExplode(',',$data,1);        // Current data set.
                $dataAcc=array();       // New data set, ready for interface (list of values, rawurlencoded)

                        // For list selectors (multi-value):
                if (intval($fieldConfig['config']['maxitems'])>1)       {

                                // Add regular elements:
                        if (is_array($fieldConfig['config']['items']))  {
                                $fieldConfig['config']['items'] = $this->procesItemArray($fieldConfig['config']['items'], $fieldConfig['config'], $TSconfig[$field], $table, $row, $field);
                                foreach($fieldConfig['config']['items'] as $pvpv)       {
                                        foreach($elements as $eKey => $value)   {
                                                if (!strcmp($value,$pvpv[1]))   {
                                                        $dataAcc[$eKey]=rawurlencode($pvpv[1]).'|'.rawurlencode($this->sL($pvpv[0]));
                                                }
                                        }
                                }
                        }

                                // Add "special"
                        if ($fieldConfig['config']['special'])  {
                                $dataAcc = $this->selectAddSpecial($dataAcc, $elements, $fieldConfig['config']['special']);
                        }

                                // Add "foreign table" stuff:
                        if ($TCA[$fieldConfig['config']['foreign_table']])      {
                                $dataAcc = $this->selectAddForeign($dataAcc, $elements, $fieldConfig, $field, $TSconfig, $row, $table);
                        }

                                // Always keep the native order for display in interface:
                        ksort($dataAcc);
                } else {        // Normal, <= 1 -> value without title on it
                        if ($TCA[$fieldConfig['config']['foreign_table']])      {
                                // Getting the data
                                $dataIds = $this->getDataIdList($elements, $fieldConfig, $row, $table);

                                if (!count($dataIds))   $dataIds = array(0);
                                $dataAcc[]=$dataIds[0];
                        } else {
                                $dataAcc[]=$elements[0];
                        }
                }

                return implode(',',$dataAcc);
        }

        function renderRecord_flexProc($data,$fieldConfig,$TSconfig,$table,$row,$field) {
                global $TCA;

                        // Convert the XML data to PHP array:
                $currentValueArray = t3lib_div::xml2array($data);
                if (is_array($currentValueArray))       {

                                // Get current value array:
                        $dataStructArray = t3lib_BEfunc::getFlexFormDS($fieldConfig['config'],$row,$table);
                        if (is_array($dataStructArray)) {
                                $currentValueArray['data'] = $this->renderRecord_flexProc_procInData($currentValueArray['data'],$dataStructArray,array($data,$fieldConfig,$TSconfig,$table,$row,$field));

                                $flexObj = t3lib_div::makeInstance('t3lib_flexformtools');
                                $data = $flexObj->flexArray2Xml($currentValueArray, TRUE);
                        }
                }

                return $data;
        }

        function renderRecord_typesProc($totalRecordContent,$types_fieldConfig,$tscPID,$table,$pid)     {
                foreach($types_fieldConfig as $vconf)   {

                                // Find file to write to, if configured:
                        $eFile = t3lib_parsehtml_proc::evalWriteFile($vconf['spec']['static_write'],$totalRecordContent);

                                // Write file configuration:
                        if (is_array($eFile))   {
                                if ($eFile['loadFromFileField'] && $totalRecordContent[$eFile['loadFromFileField']])    {
                                                // Read the external file, and insert the content between the ###TYPO3_STATICFILE_EDIT### markers:
                                        $SW_fileContent = t3lib_div::getUrl($eFile['editFile']);
                                        $parseHTML = t3lib_div::makeInstance('t3lib_parsehtml_proc');
                                        $parseHTML->init('','');

                                        $totalRecordContent[$vconf['field']] = $parseHTML->getSubpart(
                                                $SW_fileContent,
                                                $eFile['markerField']&&trim($totalRecordContent[$eFile['markerField']])
                                                        ? trim($totalRecordContent[$eFile['markerField']])
                                                        : '###TYPO3_STATICFILE_EDIT###'
                                        );
                                }
                        }
                }

                return $totalRecordContent;
        }

        function renderRecord_inlineProc($data,$fieldConfig,$TSconfig,$table,$row,$field)       {
                global $TCA;

                        // Initialize:
                $elements = t3lib_div::trimExplode(',',$data);  // Current data set.
                $dataAcc=array();       // New data set, ready for interface (list of values, rawurlencoded)
        
                $dataAcc = $this->selectAddForeign($dataAcc, $elements, $fieldConfig, $field, $TSconfig, $row, $table);
                
                return implode(',',$dataAcc);
        }












        /***********************************************
         *
         * FlexForm processing functions
         *
         ***********************************************/

        function renderRecord_flexProc_procInData($dataPart,$dataStructArray,$pParams)  {
                if (is_array($dataPart))        {
                        foreach($dataPart as $sKey => $sheetDef)        {
                                list ($dataStruct,$actualSheet) = t3lib_div::resolveSheetDefInDS($dataStructArray,$sKey);

                                if (is_array($dataStruct) && $actualSheet==$sKey && is_array($sheetDef))        {
                                        foreach($sheetDef as $lKey => $lData)   {
                                                $this->renderRecord_flexProc_procInData_travDS(
                                                        $dataPart[$sKey][$lKey],
                                                        $dataStruct['ROOT']['el'],
                                                        $pParams
                                                );
                                        }
                                }
                        }
                }

                return $dataPart;
        }

        function renderRecord_flexProc_procInData_travDS(&$dataValues,$DSelements,$pParams)             {
                if (is_array($DSelements))      {

                                // For each DS element:
                        foreach($DSelements as $key => $dsConf) {

                                                // Array/Section:
                                if ($DSelements[$key]['type']=='array') {
                                        if (is_array($dataValues[$key]['el']))  {
                                                if ($DSelements[$key]['section'])       {
                                                        foreach($dataValues[$key]['el'] as $ik => $el)  {
                                                                $theKey = key($el);
                                                                if (is_array($dataValues[$key]['el'][$ik][$theKey]['el']))      {
                                                                        $this->renderRecord_flexProc_procInData_travDS(
                                                                                        $dataValues[$key]['el'][$ik][$theKey]['el'],
                                                                                        $DSelements[$key]['el'][$theKey]['el'],
                                                                                        $pParams
                                                                                );
                                                                }
                                                        }
                                                } else {
                                                        if (!isset($dataValues[$key]['el']))    $dataValues[$key]['el']=array();
                                                        $this->renderRecord_flexProc_procInData_travDS(
                                                                        $dataValues[$key]['el'],
                                                                        $DSelements[$key]['el'],
                                                                        $pParams
                                                                );
                                                }
                                        }
                                } else {
                                        if (is_array($dsConf['TCEforms']['config']) && is_array($dataValues[$key]))     {
                                                foreach($dataValues[$key] as $vKey => $data)    {

                                                                // $data,$fieldConfig,$TSconfig,$table,$row,$field
                                                        list(,,$CVTSconfig,$CVtable,$CVrow,$CVfield) = $pParams;
;
                                                                // Set default value:
                                                        if (!isset($dataValues[$key][$vKey]))   {
                                                                $dataValues[$key][$vKey] = $dsConf['TCEforms']['config']['default'];
                                                        }

                                                                // Process value:
                                                        $dataValues[$key][$vKey] = $this->renderRecord_SW($dataValues[$key][$vKey],$dsConf['TCEforms'],$CVTSconfig,$CVtable,$CVrow,'');
                                                }
                                        }
                                }
                        }
                }
        }












        /***********************************************
         *
         * Selector box processing functions
         *
         ***********************************************/

        function selectAddSpecial($dataAcc, $elements, $specialKey)     {
                global $TCA;

                        // Special select types:
                switch ((string)$specialKey)    {
                        case 'tables':          // Listing all tables from $TCA:
                                $tNames = array_keys($TCA);
                                foreach($tNames as $tableName)  {
                                        foreach($elements as $eKey => $value)   {
                                                if (!strcmp($tableName,$value)) {
                                                        $dataAcc[$eKey]=rawurlencode($value).'|'.rawurlencode($this->sL($TCA[$value]['ctrl']['title']));
                                                }
                                        }
                                }
                        break;
                        case 'pagetypes':       // Listing all page types (doktype)
                                $theTypes = $TCA['pages']['columns']['doktype']['config']['items'];
                                if (is_array($theTypes))        {
                                        foreach($theTypes as $theTypesArrays)   {
                                                foreach($elements as $eKey => $value)   {
                                                        if (!strcmp($theTypesArrays[1],$value)) {
                                                                $dataAcc[$eKey]=rawurlencode($value).'|'.rawurlencode($this->sL($theTypesArrays[0]));
                                                        }
                                                }
                                        }
                                }
                        break;
                        case 'exclude':         // Listing exclude fields.
                                $theExcludeFields = t3lib_BEfunc::getExcludeFields();

                                if (is_array($theExcludeFields))        {
                                        foreach($theExcludeFields as $theExcludeFieldsArrays)   {
                                                foreach($elements as $eKey => $value)   {
                                                        if (!strcmp($theExcludeFieldsArrays[1],$value)) {
                                                                $dataAcc[$eKey]=rawurlencode($value).'|'.rawurlencode(ereg_replace(':$','',$theExcludeFieldsArrays[0]));
                                                        }
                                                }
                                        }
                                }
                        break;
                        case 'explicitValues':
                                $theTypes = t3lib_BEfunc::getExplicitAuthFieldValues();

                                foreach($theTypes as $tableFieldKey => $theTypeArrays)  {
                                        if (is_array($theTypeArrays['items']))  {
                                                foreach($theTypeArrays['items'] as $itemValue => $itemContent)  {
                                                        foreach($elements as $eKey => $value)   {
                                                                if (!strcmp($tableFieldKey.':'.$itemValue.':'.$itemContent[0], $value)) {
                                                                        $dataAcc[$eKey] = rawurlencode($value).'|'.rawurlencode('['.$itemContent[2].'] '.$itemContent[1]);
                                                                }
                                                        }
                                                }
                                        }
                                }
                        break;
                        case 'languages':
                                $theLangs = t3lib_BEfunc::getSystemLanguages();
                                foreach($theLangs as $lCfg)     {
                                        foreach($elements as $eKey => $value)   {
                                                if (!strcmp($lCfg[1], $value))  {
                                                        $dataAcc[$eKey] = rawurlencode($value).'|'.rawurlencode($lCfg[0]);
                                                }
                                        }
                                }
                        break;
                        case 'custom':
                                $customOptions = $GLOBALS['TYPO3_CONF_VARS']['BE']['customPermOptions'];

                                if (is_array($customOptions))   {
                                        foreach($customOptions as $coKey => $coValue) {
                                                if (is_array($coValue['items']))        {
                                                                // Traverse items:
                                                        foreach($coValue['items'] as $itemKey => $itemCfg)      {
                                                                foreach($elements as $eKey => $value)   {
                                                                        if (!strcmp($coKey.':'.$itemKey, $value))       {
                                                                                $dataAcc[$eKey] = rawurlencode($value).'|'.rawurlencode($this->sL($itemCfg[0]));
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        break;
                        case 'modListGroup':    // Listing modules for GROUPS
                        case 'modListUser':             // Listing modules for USERS:
                                if (!$this->loadModules)        {
                                        $this->loadModules = t3lib_div::makeInstance('t3lib_loadModules');
                                        $this->loadModules->load($GLOBALS['TBE_MODULES']);
                                }
                                $modList = ($specialKey=='modListUser') ? $this->loadModules->modListUser : $this->loadModules->modListGroup;

                                foreach($modList as $theModName)        {
                                        foreach($elements as $eKey => $value)   {
                                                $label = '';
                                                        // Add label for main module:
                                                $pp = explode('_',$value);
                                                if (count($pp)>1)       $label.=$GLOBALS['LANG']->moduleLabels['tabs'][$pp[0].'_tab'].'>';
                                                        // Add modules own label now:
                                                $label.= $GLOBALS['LANG']->moduleLabels['tabs'][$value.'_tab'];

                                                if (!strcmp($theModName,$value))        {
                                                        $dataAcc[$eKey]=rawurlencode($value).'|'.rawurlencode($label);
                                                }
                                        }
                                }
                        break;
                }

                return $dataAcc;
        }

        function selectAddForeign($dataAcc, $elements, $fieldConfig, $field, $TSconfig, $row, $table)   {
                global $TCA;

                        // Init:
                $recordList = Array();

                        // foreign_table
                $subres = t3lib_BEfunc::exec_foreign_table_where_query($fieldConfig,$field,$TSconfig);
                while ($subrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($subres))        {
                        $recordList[$subrow['uid']] = t3lib_BEfunc::getRecordTitle($fieldConfig['config']['foreign_table'],$subrow);
                }

                        // neg_foreign_table
                if (is_array($TCA[$fieldConfig['config']['neg_foreign_table']]))        {
                        $subres = t3lib_BEfunc::exec_foreign_table_where_query($fieldConfig,$field,$TSconfig,'neg_');
                        while ($subrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($subres))        {
                                $recordList[-$subrow['uid']] = t3lib_BEfunc::getRecordTitle($fieldConfig['config']['neg_foreign_table'],$subrow);
                        }
                }

                        // At this point all records that CAN be selected is found in $recordList
                        // Now, get the data from loadDBgroup based on the input list of values.
                $dataIds = $this->getDataIdList($elements, $fieldConfig, $row, $table);
                if ($fieldConfig['config']['MM'])       $dataAcc=array();       // Reset, if MM (which cannot bear anything but real relations!)

                        // After this we can traverse the loadDBgroup values and match values with the list of possible values in $recordList:
                foreach($dataIds as $theId)     {
                        if (isset($recordList[$theId])) {
                                $lPrefix = $this->sL($fieldConfig['config'][($theId>0?'':'neg_').'foreign_table_prefix']);
                                if ($fieldConfig['config']['MM'] || $fieldConfig['config']['foreign_field'])    {
                                        $dataAcc[]=rawurlencode($theId).'|'.rawurlencode(t3lib_div::fixed_lgd_cs($lPrefix.strip_tags($recordList[$theId]),$GLOBALS['BE_USER']->uc['titleLen']));
                                } else {
                                        foreach($elements as $eKey => $value)   {
                                                if (!strcmp($theId,$value))     {
                                                        $dataAcc[$eKey]=rawurlencode($theId).'|'.rawurlencode(t3lib_div::fixed_lgd_cs($lPrefix.strip_tags($recordList[$theId]),$GLOBALS['BE_USER']->uc['titleLen']));
                                                }
                                        }
                                }
                        }
                }

                return $dataAcc;
        }

        function getDataIdList($elements, $fieldConfig, $row, $table)   {
                $loadDB = t3lib_div::makeInstance('t3lib_loadDBGroup');
                $loadDB->registerNonTableValues=$fieldConfig['config']['allowNonIdValues'] ? 1 : 0;
                $loadDB->start(implode(',',$elements),
                        $fieldConfig['config']['foreign_table'].','.$fieldConfig['config']['neg_foreign_table'],
                        $fieldConfig['config']['MM'],
                        $row['uid'],
                        $table,
                        $fieldConfig['config']
                );

                $idList = $loadDB->convertPosNeg($loadDB->getValueArray(),$fieldConfig['config']['foreign_table'],$fieldConfig['config']['neg_foreign_table']);

                return $idList;
        }

        function procesItemArray($selItems,$config,$fieldTSConfig,$table,$row,$field)   {
                $selItems = $this->addItems($selItems,$fieldTSConfig['addItems.']);
                if ($config['itemsProcFunc']) $selItems = $this->procItems($selItems,$fieldTSConfig['itemsProcFunc.'],$config,$table,$row,$field);
                return $selItems;
        }

        function addItems($items,$iArray)       {
                if (is_array($iArray))  {
                        foreach($iArray as $value => $label)    {
                                $items[]=array($label,$value);
                        }
                }
                return $items;
        }

        function procItems($items,$itemsProcFuncTSconfig,$config,$table,$row,$field)    {
                $params=array();
                $params['items'] = &$items;
                $params['config'] = $config;
                $params['TSconfig'] = $itemsProcFuncTSconfig;
                $params['table'] = $table;
                $params['row'] = $row;
                $params['field'] = $field;

                t3lib_div::callUserFunction($config['itemsProcFunc'],$params,$this);
                return $items;
        }









        /***********************************************
         *
         * Helper functions
         *
         ***********************************************/

        function lockRecord($table, $id, $pid=0)        {
                if ($this->lockRecords) {
                        t3lib_BEfunc::lockRecords($table,$id,$pid);
                }
        }

        function regItem($table, $id, $field, $content) {
        }

        function sL($in)        {
                return $GLOBALS['LANG']->sL($in);
        }
}


if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_transferdata.php'])      {
        include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_transferdata.php']);
}
?>

---