t3lib/class.t3lib_tceforms_inline.php

   1 <?php
   2 /***************************************************************
   3 *  Copyright notice
   4 *
   5 *  (c) 2006-2007 Oliver Hader <oh@inpublica.de>
   6 *  All rights reserved
   7 *
   8 *  This script is part of the TYPO3 project. The TYPO3 project is
   9 *  free software; you can redistribute it and/or modify
  10 *  it under the terms of the GNU General Public License as published by
  11 *  the Free Software Foundation; either version 2 of the License, or
  12 *  (at your option) any later version.
  13 *
  14 *  The GNU General Public License can be found at
  15 *  http://www.gnu.org/copyleft/gpl.html.
  16 *  A copy is found in the textfile GPL.txt and important notices to the license
  17 *  from the author is found in LICENSE.txt distributed with these scripts.
  18 *
  19 *
  20 *  This script is distributed in the hope that it will be useful,
  21 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23 *  GNU General Public License for more details.
  24 *
  25 *  This copyright notice MUST APPEAR in all copies of the script!
  26 ***************************************************************/
  27 /**
  28  * The Inline-Relational-Record-Editing (IRRE) functions as part of the TCEforms.
  29  *
  30  * $Id$
  31  *
  32  * @author      Oliver Hader <oh@inpublica.de>
  33  */
  34 /**
  35  * [CLASS/FUNCTION INDEX of SCRIPT]
  36  *
  37  *
  38  *
  39  *   88: class t3lib_TCEforms_inline
  40  *  109:     function init(&$tceForms)
  41  *  127:     function getSingleField_typeInline($table,$field,$row,&$PA)
  42  *
  43  *              SECTION: Regular rendering of forms, fields, etc.
  44  *  263:     function renderForeignRecord($parentUid, $rec, $config = array())
  45  *  319:     function renderForeignRecordHeader($parentUid, $foreign_table,$rec,$config = array())
  46  *  375:     function renderForeignRecordHeaderControl($table,$row,$config = array())
  47  *  506:     function renderCombinationTable(&$rec, $appendFormFieldNames, $config = array())
  48  *  560:     function renderPossibleRecordsSelector($selItems, $conf, $uniqueIds=array())
  49  *  627:     function addJavaScript()
  50  *  643:     function addJavaScriptSortable($objectId)
  51  *
  52  *              SECTION: Handling of AJAX calls
  53  *  665:     function createNewRecord($domObjectId, $foreignUid = 0)
  54  *  755:     function getJSON($jsonArray)
  55  *  770:     function getNewRecordLink($objectPrefix, $conf = array())
  56  *
  57  *              SECTION: Get data from database and handle relations
  58  *  807:     function getRelatedRecords($table,$field,$row,&$PA,$config)
  59  *  839:     function getPossibleRecords($table,$field,$row,$conf,$checkForConfField='foreign_selector')
  60  *  885:     function getUniqueIds($records, $conf=array())
  61  *  905:     function getRecord($pid, $table, $uid, $cmd='')
  62  *  929:     function getNewRecord($pid, $table)
  63  *
  64  *              SECTION: Structure stack for handling inline objects/levels
  65  *  951:     function pushStructure($table, $uid, $field = '', $config = array())
  66  *  967:     function popStructure()
  67  *  984:     function updateStructureNames()
  68  * 1000:     function getStructureItemName($levelData)
  69  * 1015:     function getStructureLevel($level)
  70  * 1032:     function getStructurePath($structureDepth = -1)
  71  * 1057:     function parseStructureString($string, $loadConfig = false)
  72  *
  73  *              SECTION: Helper functions
  74  * 1098:     function checkConfiguration(&$config)
  75  * 1123:     function checkAccess($cmd, $table, $theUid)
  76  * 1185:     function compareStructureConfiguration($compare)
  77  * 1199:     function normalizeUid($string)
  78  * 1213:     function wrapFormsSection($section, $styleAttrs = array(), $tableAttrs = array())
  79  * 1242:     function isInlineChildAndLabelField($table, $field)
  80  * 1258:     function getStructureDepth()
  81  * 1295:     function arrayCompareComplex($subjectArray, $searchArray, $type = '')
  82  * 1349:     function isAssociativeArray($object)
  83  * 1364:     function getPossibleRecordsFlat($possibleRecords)
  84  * 1383:     function skipField($table, $field, $row, $config)
  85  *
  86  * TOTAL FUNCTIONS: 35
  87  * (This index is automatically created/updated by the extension "extdeveval")
  88  *
  89  */
  90 class t3lib_TCEforms_inline {
  91
  92         /**
  93          * Reference to the calling TCEforms instance
  94          *
  95          * @var t3lib_TCEforms
  96          */
  97         var $fObj;
  98         var $backPath;                                                  // Reference to $fObj->backPath
  99
 100         var $isAjaxCall = false;                                // Indicates if a field is rendered upon an AJAX call
 101         var $inlineStructure = array();                 // the structure/hierarchy where working in, e.g. cascading inline tables
 102         var $inlineFirstPid;                                    // the first call of an inline type appeared on this page (pid of record)
 103         var $inlineNames = array();                             // keys: form, object -> hold the name/id for each of them
 104         var $inlineData = array();                              // inline data array used for JSON output
 105         var $inlineView = array();                              // expanded/collapsed states for the current BE user
 106         var $inlineCount = 0;                                   // count the number of inline types used
 107         var $inlineStyles = array();
 108
 109         var $prependNaming = 'data';                    // how the $this->fObj->prependFormFieldNames should be set ('data' is default)
 110         var $prependFormFieldNames;                             // reference to $this->fObj->prependFormFieldNames
 111         var $prependCmdFieldNames;                              // reference to $this->fObj->prependCmdFieldNames
 112
 113
 114         /**
 115          * Intialize an instance of t3lib_TCEforms_inline
 116          *
 117          * @param       t3lib_TCEforms          $tceForms: Reference to an TCEforms instance
 118          * @return      void
 119          */
 120         function init(&$tceForms) {
 121                 $this->fObj =& $tceForms;
 122                 $this->backPath =& $tceForms->backPath;
 123                 $this->prependFormFieldNames =& $this->fObj->prependFormFieldNames;
 124                 $this->prependCmdFieldNames =& $this->fObj->prependCmdFieldNames;
 125                 $this->inlineStyles['margin-right'] = '5';
 126         }
 127
 128
 129         /**
 130          * Generation of TCEform elements of the type "inline"
 131          * This will render inline-relational-record sets. Relations.
 132          *
 133          * @param       string          $table: The table name of the record
 134          * @param       string          $field: The field name which this element is supposed to edit
 135          * @param       array           $row: The record data array where the value(s) for the field can be found
 136          * @param       array           $PA: An array with additional configuration options.
 137          * @return      string          The HTML code for the TCEform field
 138          */
 139         function getSingleField_typeInline($table,$field,$row,&$PA) {
 140                         // check the TCA configuration - if false is returned, something was wrong
 141                 if ($this->checkConfiguration($PA['fieldConf']['config']) === false) return false;
 142
 143                         // count the number of processed inline elements
 144                 $this->inlineCount++;
 145
 146                         // Init:
 147                 $config = $PA['fieldConf']['config'];
 148                 $foreign_table = $config['foreign_table'];
 149                 t3lib_div::loadTCA($foreign_table);
 150
 151                 $minitems = t3lib_div::intInRange($config['minitems'],0);
 152                 $maxitems = t3lib_div::intInRange($config['maxitems'],0);
 153                 if (!$maxitems) $maxitems=100000;
 154
 155                         // Register the required number of elements:
 156                 $this->fObj->requiredElements[$PA['itemFormElName']] = array($minitems,$maxitems,'imgName'=>$table.'_'.$row['uid'].'_'.$field);
 157
 158                         // remember the page id (pid of record) where inline editing started first
 159                         // we need that pid for ajax calls, so that they would know where the action takes place on the page structure
 160                 if (!isset($this->inlineFirstPid)) {
 161                                 // if this record is not new, try to fetch the inlineView states
 162                                 // @TODO: Add checking/cleaning for unused tables, records, etc. to save space in uc-field
 163                         if (t3lib_div::testInt($row['uid'])) {
 164                                 $inlineView = unserialize($GLOBALS['BE_USER']->uc['inlineView']);
 165                                 $this->inlineView = $inlineView[$table][$row['uid']];
 166                         }
 167                                 // If the parent is a page, use the uid(!) of the (new?) page as pid for the child records:
 168                         if ($table == 'pages') {
 169                                 $this->inlineFirstPid = $row['uid'];
 170                                 // If pid is negative, fetch the previous record and take its pid:
 171                         } elseif ($row['pid'] < 0) {
 172                                 $prevRec = t3lib_BEfunc::getRecord($table, abs($row['pid']));
 173                                 $this->inlineFirstPid = $prevRec['pid'];
 174                                 // Take the pid as it is:
 175                         } else {
 176                                 $this->inlineFirstPid = $row['pid'];
 177                         }
 178                 }
 179                         // add the current inline job to the structure stack
 180                 $this->pushStructure($table, $row['uid'], $field, $config);
 181                         // e.g. inline[<table>][<uid>][<field>]
 182                 $nameForm = $this->inlineNames['form'];
 183                         // e.g. inline[<pid>][<table1>][<uid1>][<field1>][<table2>][<uid2>][<field2>]
 184                 $nameObject = $this->inlineNames['object'];
 185                         // get the records related to this inline record
 186                 $recordList = $this->getRelatedRecords($table,$field,$row,$PA,$config);
 187                         // set the first and last record to the config array
 188                 $config['inline']['first'] = $recordList[0]['uid'];
 189                 $config['inline']['last'] = $recordList[count($recordList)-1]['uid'];
 190
 191                         // Tell the browser what we have (using JSON later):
 192                 $top = $this->getStructureLevel(0);
 193                 $this->inlineData['config'][$nameObject] = array('table' => $foreign_table);
 194                 $this->inlineData['config'][$nameObject.'['.$foreign_table.']'] = array(
 195                         'min' => $minitems,
 196                         'max' => $maxitems,
 197                         'sortable' => $config['appearance']['useSortable'],
 198                         'top' => array(
 199                                 'table' => $top['table'],
 200                                 'uid'   => $top['uid'],
 201                         ),
 202                 );
 203                         // Set a hint for nested IRRE and tab elements:
 204                 $this->inlineData['nested'][$nameObject] = $this->fObj->getDynNestedStack(false, $this->isAjaxCall);
 205
 206                         // if relations are required to be unique, get the uids that have already been used on the foreign side of the relation
 207                 if ($config['foreign_unique']) {
 208                                 // If uniqueness *and* selector are set, they should point to the same field - so, get the configuration of one:
 209                         $selConfig = $this->getPossibleRecordsSelectorConfig($config, $config['foreign_unique']);
 210                                 // Get the used unique ids:
 211                         $uniqueIds = $this->getUniqueIds($recordList, $config, $selConfig['type']=='groupdb');
 212                         $possibleRecords = $this->getPossibleRecords($table,$field,$row,$config,'foreign_unique');
 213                         $uniqueMax = $config['appearance']['useCombination'] || $possibleRecords === false ? -1 : count($possibleRecords);
 214                         $this->inlineData['unique'][$nameObject.'['.$foreign_table.']'] = array(
 215                                 'max' => $uniqueMax,
 216                                 'used' => $uniqueIds,
 217                                 'type' => $selConfig['type'],
 218                                 'table' => $config['foreign_table'],
 219                                 'elTable' => $selConfig['table'], // element/record table (one step down in hierarchy)
 220                                 'field' => $config['foreign_unique'],
 221                                 'selector' => $selConfig['selector'],
 222                                 'possible' => $this->getPossibleRecordsFlat($possibleRecords),
 223                         );
 224                 }
 225
 226                         // if it's required to select from possible child records (reusable children), add a selector box
 227                 if ($config['foreign_selector']) {
 228                                 // if not already set by the foreign_unique, set the possibleRecords here and the uniqueIds to an empty array
 229                         if (!$config['foreign_unique']) {
 230                                 $possibleRecords = $this->getPossibleRecords($table,$field,$row,$config);
 231                                 $uniqueIds = array();
 232                         }
 233                         $selectorBox = $this->renderPossibleRecordsSelector($possibleRecords,$config,$uniqueIds);
 234                         $item .= $selectorBox;
 235                 }
 236
 237                         // wrap all inline fields of a record with a <div> (like a container)
 238                 $item .= '<div id="'.$nameObject.'">';
 239
 240                         // define how to show the "Create new record" link - if there are more than maxitems, hide it
 241                 if (count($recordList) >= $maxitems || ($uniqueMax > 0 && count($recordList) >= $uniqueMax)) {
 242                         $config['inline']['inlineNewButtonStyle'] = 'display: none;';
 243                 }
 244                         // add the "Create new record" link before all child records
 245                 if (in_array($config['appearance']['newRecordLinkPosition'], array('both', 'top'))) {
 246                         $item .= $this->getNewRecordLink($nameObject.'['.$foreign_table.']', $config);
 247                 }
 248
 249                 $item .= '<div id="'.$nameObject.'_records">';
 250                 $relationList = array();
 251                 if (count($recordList)) {
 252                         foreach ($recordList as $rec) {
 253                                 $item .= $this->renderForeignRecord($row['uid'],$rec,$config);
 254                                 $relationList[] = $rec['uid'];
 255                         }
 256                 }
 257                 $item .= '</div>';
 258
 259                         // add the "Create new record" link after all child records
 260                 if (in_array($config['appearance']['newRecordLinkPosition'], array('both', 'bottom'))) {
 261                         $item .= $this->getNewRecordLink($nameObject.'['.$foreign_table.']', $config);
 262                 }
 263
 264                         // add Drag&Drop functions for sorting to TCEforms::$additionalJS_post
 265                 if (count($relationList) > 1 && $config['appearance']['useSortable'])
 266                         $this->addJavaScriptSortable($nameObject.'_records');
 267                         // publish the uids of the child records in the given order to the browser
 268                 $item .= '<input type="hidden" name="'.$nameForm.'" value="'.implode(',', $relationList).'" class="inlineRecord" />';
 269                         // close the wrap for all inline fields (container)
 270                 $item .= '</div>';
 271
 272                         // on finishing this section, remove the last item from the structure stack
 273                 $this->popStructure();
 274
 275                         // if this was the first call to the inline type, restore the values
 276                 if (!$this->getStructureDepth()) {
 277                         unset($this->inlineFirstPid);
 278                 }
 279
 280                 return $item;
 281         }
 282
 283
 284         /*******************************************************
 285          *
 286          * Regular rendering of forms, fields, etc.
 287          *
 288          *******************************************************/
 289
 290
 291         /**
 292          * Render the form-fields of a related (foreign) record.
 293          *
 294          * @param       string          $parentUid: The uid of the parent (embedding) record (uid or NEW...)
 295          * @param       array           $rec: The table record of the child/embedded table (normaly post-processed by t3lib_transferData)
 296          * @param       array           $config: content of $PA['fieldConf']['config']
 297          * @return      string          The HTML code for this "foreign record"
 298          */
 299         function renderForeignRecord($parentUid, $rec, $config = array()) {
 300                 $foreign_table = $config['foreign_table'];
 301                 $foreign_field = $config['foreign_field'];
 302                 $foreign_selector = $config['foreign_selector'];
 303
 304                         // Send a mapping information to the browser via JSON:
 305                         // e.g. data[<curTable>][<curId>][<curField>] => data[<pid>][<parentTable>][<parentId>][<parentField>][<curTable>][<curId>][<curField>]
 306                 $this->inlineData['map'][$this->inlineNames['form']] = $this->inlineNames['object'];
 307
 308                         // Set this variable if we handle a brand new unsaved record:
 309                 $isNewRecord = t3lib_div::testInt($rec['uid']) ? false : true;
 310                         // If there is a selector field, normalize it:
 311                 if ($foreign_selector) {
 312                         $rec[$foreign_selector] = $this->normalizeUid($rec[$foreign_selector]);
 313                 }
 314
 315                 $hasAccess = $this->checkAccess($isNewRecord?'new':'edit', $foreign_table, $rec['uid']);
 316
 317                 if(!$hasAccess) return false;
 318
 319                         // Get the current naming scheme for DOM name/id attributes:
 320                 $nameObject = $this->inlineNames['object'];
 321                 $appendFormFieldNames = '['.$foreign_table.']['.$rec['uid'].']';
 322                 $formFieldNames = $nameObject.$appendFormFieldNames;
 323                         // Put the current level also to the dynNestedStack of TCEforms:
 324                 $this->fObj->pushToDynNestedStack('inline', $this->inlineNames['object'].$appendFormFieldNames);
 325
 326                 $header = $this->renderForeignRecordHeader($parentUid, $foreign_table, $rec, $config);
 327                 $combination = $this->renderCombinationTable($rec, $appendFormFieldNames, $config);
 328                 $fields = $this->fObj->getMainFields($foreign_table,$rec);
 329                 $fields = $this->wrapFormsSection($fields);
 330
 331                 if ($isNewRecord) {
 332                                 // show this record expanded or collapsed
 333                         $isExpanded = is_array($config['appearance']) && $config['appearance']['collapseAll'] ? 1 : 0;
 334                                 // get the top parent table
 335                         $top = $this->getStructureLevel(0);
 336                         $ucFieldName = 'uc['.$top['table'].']['.$top['uid'].']'.$appendFormFieldNames;
 337                                 // set additional fields for processing for saving
 338                         $fields .= '<input type="hidden" name="'.$this->prependFormFieldNames.$appendFormFieldNames.'[pid]" value="'.$rec['pid'].'"/>';
 339                         $fields .= '<input type="hidden" name="'.$ucFieldName.'" value="'.$isExpanded.'" />';
 340
 341                 } else {
 342                                 // show this record expanded or collapsed
 343                         $isExpanded = $this->getExpandedCollapsedState($foreign_table, $rec['uid']);
 344                                 // set additional field for processing for saving
 345                         $fields .= '<input type="hidden" name="'.$this->prependCmdFieldNames.$appendFormFieldNames.'[delete]" value="1" disabled="disabled" />';
 346                 }
 347
 348                         // if this record should be shown collapsed
 349                 if (!$isExpanded) $appearanceStyleFields = ' style="display: none;"';
 350
 351                         // set the record container with data for output
 352                 $out = '<div id="'.$formFieldNames.'_header">'.$header.'</div>';
 353                 $out .= '<div id="'.$formFieldNames.'_fields"'.$appearanceStyleFields.'>'.$fields.$combination.'</div>';
 354                         // wrap the header, fields and combination part of a child record with a div container
 355                 $out = '<div id="'.$formFieldNames.'_div" class="inlineDiv'.($isNewRecord ? ' inlineIsNewRecord' : '').'">' . $out . '</div>';
 356
 357                         // Remove the current level also from the dynNestedStack of TCEforms:
 358                 $this->fObj->popFromDynNestedStack();
 359
 360                 return $out;
 361         }
 362
 363
 364         /**
 365          * Renders the HTML header for a foreign record, such as the title, toggle-function, drag'n'drop, etc.
 366          * Later on the command-icons are inserted here.
 367          *
 368          * @param       string          $parentUid: The uid of the parent (embedding) record (uid or NEW...)
 369          * @param       string          $foreign_table: The foreign_table we create a header for
 370          * @param       array           $rec: The current record of that foreign_table
 371          * @param       array           $config: content of $PA['fieldConf']['config']
 372          * @return      string          The HTML code of the header
 373          */
 374         function renderForeignRecordHeader($parentUid, $foreign_table, $rec, $config = array()) {
 375                         // Init:
 376                 $formFieldNames = $this->inlineNames['object'].'['.$foreign_table.']['.$rec['uid'].']';
 377                 $expandSingle = $config['appearance']['expandSingle'] ? 1 : 0;
 378                 $onClick = "return inline.expandCollapseRecord('".htmlspecialchars($formFieldNames)."', $expandSingle)";
 379
 380                         // Pre-Processing:
 381                 $isOnSymmetricSide = t3lib_loadDBGroup::isOnSymmetricSide($parentUid, $config, $rec);
 382                 $hasForeignLabel = !$isOnSymmetricSide && $config['foreign_label'] ? true : false;
 383                 $hasSymmetricLabel = $isOnSymmetricSide && $config['symmetric_label'] ? true : false;
 384                         // Get the record title/label for a record:
 385                         // render using a self-defined user function
 386                 if ($GLOBALS['TCA'][$foreign_table]['ctrl']['label_userFunc']) {
 387                         $params = array(
 388                                 'table' => $foreign_table,
 389                                 'row'   => $rec,
 390                                 'title' => '',
 391                                 'isOnSymmetricSide' => $isOnSymmetricSide,
 392                                 'parent' => array(
 393                                         'uid' => $parentUid,
 394                                         'config' => $config,
 395                                 ),
 396                         );
 397                         $null = null;   // callUserFunction requires a third parameter, but we don't want to give $this as reference!
 398                         t3lib_div::callUserFunction($GLOBALS['TCA'][$foreign_table]['ctrl']['label_userFunc'], $params, $null);
 399                         $recTitle = $params['title'];
 400                         // render the special alternative title
 401                 } elseif ($hasForeignLabel || $hasSymmetricLabel) {
 402                         $titleCol = $hasForeignLabel ? $config['foreign_label'] : $config['symmetric_label'];
 403                         $foreignConfig = $this->getPossibleRecordsSelectorConfig($config, $titleCol);
 404                                 // Render title for everything else than group/db:
 405                         if ($foreignConfig['type'] != 'groupdb') {
 406                                 $recTitle = t3lib_BEfunc::getProcessedValueExtra($foreign_table, $titleCol, $rec[$titleCol], 0, 0, false);
 407                                 // Render title for group/db:
 408                         } else {
 409                                         // $recTitle could be something like: "tx_table_123|...",
 410                                 $valueParts = t3lib_div::trimExplode('|', $rec[$titleCol]);
 411                                 $itemParts = t3lib_div::revExplode('_', $valueParts[0], 2);
 412                                 $recTemp = t3lib_befunc::getRecordWSOL($itemParts[0], $itemParts[1]);
 413                                 $recTitle = t3lib_BEfunc::getRecordTitle($itemParts[0], $recTemp, true);
 414                         }
 415                         $recTitle = t3lib_BEfunc::getRecordTitlePrep($recTitle);
 416                         if (!strcmp(trim($recTitle),'')) {
 417                                 $recTitle = t3lib_BEfunc::getNoRecordTitle(true);
 418                         }
 419                         // render the standard
 420                 } else {
 421                         $recTitle = t3lib_BEfunc::getRecordTitle($foreign_table, $rec, true);
 422                 }
 423
 424                 $altText = t3lib_BEfunc::getRecordIconAltText($rec, $foreign_table);
 425                 $iconImg =
 426                         '<a href="#" onclick="'.htmlspecialchars($onClick).'">'.t3lib_iconWorks::getIconImage(
 427                                 $foreign_table, $rec, $this->backPath,
 428                                 'title="'.htmlspecialchars($altText).'" class="absmiddle"'
 429                         ).'</a>';
 430
 431                 $label =
 432                         '<a href="#" onclick="'.htmlspecialchars($onClick).'" style="display: block;">'.
 433                                 '<span id="'.$formFieldNames.'_label">'.$recTitle.'</span>'.
 434                         '</a>';
 435
 436                 $ctrl = $this->renderForeignRecordHeaderControl($parentUid, $foreign_table, $rec, $config);
 437
 438                         // @TODO: Check the table wrapping and the CSS definitions
 439                 $header =
 440                         '<table cellspacing="0" cellpadding="0" border="0" width="100%" style="margin-right: '.$this->inlineStyles['margin-right'].'px;"'.
 441                         ($this->fObj->borderStyle[2] ? ' background="'.htmlspecialchars($this->backPath.$this->fObj->borderStyle[2]).'"':'').
 442                         ($this->fObj->borderStyle[3] ? ' class="'.htmlspecialchars($this->fObj->borderStyle[3]).'"':'').'>' .
 443                         '<tr class="class-main12"><td width="18">'.$iconImg.'</td><td align="left"><b>'.$label.'</b></td><td align="right">'.$ctrl.'</td></tr></table>';
 444
 445                 return $header;
 446         }
 447
 448
 449         /**
 450          * Render the control-icons for a record header (create new, sorting, delete, disable/enable).
 451          * Most of the parts are copy&paste from class.db_list_extra.inc and modified for the JavaScript calls here
 452          *
 453          * @param       string          $parentUid: The uid of the parent (embedding) record (uid or NEW...)
 454          * @param       string          $foreign_table: The table (foreign_table) we create control-icons for
 455          * @param       array           $rec: The current record of that foreign_table
 456          * @param       array           $config: (modified) TCA configuration of the field
 457          * @return      string          The HTML code with the control-icons
 458          */
 459         function renderForeignRecordHeaderControl($parentUid, $foreign_table, $rec, $config = array()) {
 460                         // Initialize:
 461                 $cells=array();
 462                 $isNewItem = substr($rec['uid'], 0, 3) == 'NEW';
 463
 464                 $tcaTableCtrl =& $GLOBALS['TCA'][$foreign_table]['ctrl'];
 465                 $tcaTableCols =& $GLOBALS['TCA'][$foreign_table]['columns'];
 466
 467                 $isPagesTable = $foreign_table == 'pages' ? true : false;
 468                 $isOnSymmetricSide = t3lib_loadDBGroup::isOnSymmetricSide($parentUid, $config, $rec);
 469                 $enableManualSorting = $tcaTableCtrl['sortby'] || $config['MM'] || (!$isOnSymmetricSide && $config['foreign_sortby']) || ($isOnSymmetricSide && $config['symmetric_sortby']) ? true : false;
 470
 471                 $nameObjectFt = $this->inlineNames['object'].'['.$foreign_table.']';
 472                 $nameObjectFtId = $nameObjectFt.'['.$rec['uid'].']';
 473
 474                 $calcPerms = $GLOBALS['BE_USER']->calcPerms(
 475                         t3lib_BEfunc::readPageAccess($rec['pid'], $GLOBALS['BE_USER']->getPagePermsClause(1))
 476                 );
 477
 478                         // If the listed table is 'pages' we have to request the permission settings for each page:
 479                 if ($isPagesTable)      {
 480                         $localCalcPerms = $GLOBALS['BE_USER']->calcPerms(t3lib_BEfunc::getRecord('pages',$rec['uid']));
 481                 }
 482
 483                         // This expresses the edit permissions for this particular element:
 484                 $permsEdit = ($isPagesTable && ($localCalcPerms&2)) || (!$isPagesTable && ($calcPerms&16));
 485
 486                         // "Info": (All records)
 487                 if (!$isNewItem)
 488                         $cells[]='<a href="#" onclick="'.htmlspecialchars('top.launchView(\''.$foreign_table.'\', \''.$rec['uid'].'\'); return false;').'">'.
 489                                 '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/zoom2.gif','width="12" height="12"').' title="'.$GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_mod_web_list.xml:showInfo',1).'" alt="" />'.
 490                                 '</a>';
 491
 492                         // If the table is NOT a read-only table, then show these links:
 493                 if (!$tcaTableCtrl['readOnly']) {
 494
 495                                 // "New record after" link (ONLY if the records in the table are sorted by a "sortby"-row or if default values can depend on previous record):
 496                         if ($enableManualSorting || $tcaTableCtrl['useColumnsForDefaultValues'])        {
 497                                 if (
 498                                         (!$isPagesTable && ($calcPerms&16)) ||  // For NON-pages, must have permission to edit content on this parent page
 499                                         ($isPagesTable && ($calcPerms&8))               // For pages, must have permission to create new pages here.
 500                                         )       {
 501                                         $onClick = "return inline.createNewRecord('".$nameObjectFt."','".$rec['uid']."')";
 502                                         if ($config['inline']['inlineNewButtonStyle']) {
 503                                                 $style = ' style="'.$config['inline']['inlineNewButtonStyle'].'"';
 504                                         }
 505                                         $cells[]='<a href="#" onclick="'.htmlspecialchars($onClick).'" class="inlineNewButton"'.$style.'>'.
 506                                                         '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/new_'.($isPagesTable?'page':'el').'.gif','width="'.($isPagesTable?13:11).'" height="12"').' title="'.$GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_mod_web_list.xml:new'.($isPagesTable?'Page':'Record'),1).'" alt="" />'.
 507                                                         '</a>';
 508                                 }
 509                         }
 510
 511                                 // Drag&Drop Sorting: Sortable handler for script.aculo.us
 512                         if ($permsEdit && $enableManualSorting && $config['appearance']['useSortable']) {
 513                                 $cells[] = '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/move.gif','width="16" height="16" hspace="2"').' title="'.$GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.php:labels.move',1).'" alt="" style="cursor: move;" class="sortableHandle" />';
 514                         }
 515
 516                                 // "Up/Down" links
 517                         if ($permsEdit && $enableManualSorting) {
 518                                 $onClick = "return inline.changeSorting('".$nameObjectFtId."', '1')";   // Up
 519                                 $style = $config['inline']['first'] == $rec['uid'] ? 'style="visibility: hidden;"' : '';
 520                                 $cells[]='<a href="#" onclick="'.htmlspecialchars($onClick).'" class="sortingUp" '.$style.'>'.
 521                                                 '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/button_up.gif','width="11" height="10"').' title="'.$GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_mod_web_list.xml:moveUp',1).'" alt="" />'.
 522                                                 '</a>';
 523
 524                                 $onClick = "return inline.changeSorting('".$nameObjectFtId."', '-1')";  // Down
 525                                 $style = $config['inline']['last'] == $rec['uid'] ? 'style="visibility: hidden;"' : '';
 526                                 $cells[]='<a href="#" onclick="'.htmlspecialchars($onClick).'" class="sortingDown" '.$style.'>'.
 527                                                 '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/button_down.gif','width="11" height="10"').' title="'.$GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_mod_web_list.xml:moveDown',1).'" alt="" />'.
 528                                                 '</a>';
 529                         }
 530
 531                                 // "Hide/Unhide" links:
 532                         $hiddenField = $tcaTableCtrl['enablecolumns']['disabled'];
 533                         if ($permsEdit && $hiddenField && $tcaTableCols[$hiddenField] && (!$tcaTableCols[$hiddenField]['exclude'] || $GLOBALS['BE_USER']->check('non_exclude_fields',$foreign_table.':'.$hiddenField))) {
 534                                 $onClick = "return inline.enableDisableRecord('".$nameObjectFtId."')";
 535                                 if ($rec[$hiddenField]) {
 536                                         $cells[]='<a href="#" onclick="'.htmlspecialchars($onClick).'">'.
 537                                                         '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/button_unhide.gif','width="11" height="10"').' title="'.$GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_mod_web_list.xml:unHide'.($isPagesTable?'Page':''),1).'" alt="" id="'.$nameObjectFtId.'_disabled" />'.
 538                                                         '</a>';
 539                                 } else {
 540                                         $cells[]='<a href="#" onclick="'.htmlspecialchars($onClick).'">'.
 541                                                         '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/button_hide.gif','width="11" height="10"').' title="'.$GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_mod_web_list.xml:hide'.($isPagesTable?'Page':''),1).'" alt="" id="'.$nameObjectFtId.'_disabled" />'.
 542                                                         '</a>';
 543                                 }
 544                         }
 545
 546                                 // "Delete" link:
 547                         if (
 548                                 ($isPagesTable && ($localCalcPerms&4)) || (!$isPagesTable && ($calcPerms&16))
 549                                 )       {
 550                                 $onClick = "inline.deleteRecord('".$nameObjectFtId."');";
 551                                 $cells[]='<a href="#" onclick="'.htmlspecialchars('if (confirm('.$GLOBALS['LANG']->JScharCode($GLOBALS['LANG']->getLL('deleteWarning')).')) {   '.$onClick.' } return false;').'">'.
 552                                                 '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/garbage.gif','width="11" height="12"').' title="'.$GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_mod_web_list.xml:delete',1).'" alt="" />'.
 553                                                 '</a>';
 554                         }
 555                 }
 556
 557                         // If the record is edit-locked by another user, we will show a little warning sign:
 558                 if ($lockInfo=t3lib_BEfunc::isRecordLocked($foreign_table,$rec['uid'])) {
 559                         $cells[]='<a href="#" onclick="'.htmlspecialchars('alert('.$GLOBALS['LANG']->JScharCode($lockInfo['msg']).');return false;').'">'.
 560                                         '<img'.t3lib_iconWorks::skinImg('','gfx/recordlock_warning3.gif','width="17" height="12"').' title="'.htmlspecialchars($lockInfo['msg']).'" alt="" />'.
 561                                         '</a>';
 562                 }
 563
 564                         // Compile items into a DIV-element:
 565                 return '
 566                                                                                         <!-- CONTROL PANEL: '.$foreign_table.':'.$rec['uid'].' -->
 567                                                                                         <div class="typo3-DBctrl">'.implode('',$cells).'</div>';
 568         }
 569
 570
 571         /**
 572          * Render a table with TCEforms, that occurs on a intermediate table but should be editable directly,
 573          * so two tables are combined (the intermediate table with attributes and the sub-embedded table).
 574          * -> This is a direct embedding over two levels!
 575          *
 576          * @param       array           $rec: The table record of the child/embedded table (normaly post-processed by t3lib_transferData)
 577          * @param       string          $appendFormFieldNames: The [<table>][<uid>] of the parent record (the intermediate table)
 578          * @param       array           $config: content of $PA['fieldConf']['config']
 579          * @return      string          A HTML string with <table> tag around.
 580          */
 581         function renderCombinationTable(&$rec, $appendFormFieldNames, $config = array()) {
 582                 $foreign_table = $config['foreign_table'];
 583                 $foreign_selector = $config['foreign_selector'];
 584
 585                 if ($foreign_selector && $config['appearance']['useCombination']) {
 586                         $comboConfig = $GLOBALS['TCA'][$foreign_table]['columns'][$foreign_selector]['config'];
 587                         $comboRecord = array();
 588
 589                                 // If record does already exist, load it:
 590                         if ($rec[$foreign_selector] && t3lib_div::testInt($rec[$foreign_selector])) {
 591                                 $comboRecord = $this->getRecord(
 592                                         $this->inlineFirstPid,
 593                                         $comboConfig['foreign_table'],
 594                                         $rec[$foreign_selector]
 595                                 );
 596                                 $isNewRecord = false;
 597                                 // It is a new record, create a new record virtually:
 598                         } else {
 599                                 $comboRecord = $this->getNewRecord(
 600                                         $this->inlineFirstPid,
 601                                         $comboConfig['foreign_table']
 602                                 );
 603                                 $isNewRecord = true;
 604                         }
 605
 606                                 // get the TCEforms interpretation of the TCA of the child table
 607                         $out = $this->fObj->getMainFields($comboConfig['foreign_table'], $comboRecord);
 608                         $out = $this->wrapFormsSection($out, array(), array('class' => 'wrapperAttention'));
 609
 610                                 // if this is a new record, add a pid value to store this record and the pointer value for the intermediate table
 611                         if ($isNewRecord) {
 612                                 $comboFormFieldName = $this->prependFormFieldNames.'['.$comboConfig['foreign_table'].']['.$comboRecord['uid'].'][pid]';
 613                                 $out .= '<input type="hidden" name="'.$comboFormFieldName.'" value="'.$this->inlineFirstPid.'"/>';
 614                         }
 615
 616                                 // if the foreign_selector field is also responsible for uniqueness, tell the browser the uid of the "other" side of the relation
 617                         if ($isNewRecord || $config['foreign_unique'] == $foreign_selector) {
 618                                 $parentFormFieldName = $this->prependFormFieldNames.$appendFormFieldNames.'['.$foreign_selector.']';
 619                                 $out .= '<input type="hidden" name="'.$parentFormFieldName.'" value="'.$comboRecord['uid'].'" />';
 620                         }
 621                 }
 622
 623                 return $out;
 624         }
 625
 626
 627         /**
 628          * Get a selector as used for the select type, to select from all available
 629          * records and to create a relation to the embedding record (e.g. like MM).
 630          *
 631          * @param       array           $selItems: Array of all possible records
 632          * @param       array           $conf: TCA configuration of the parent(!) field
 633          * @param       array           $uniqueIds: The uids that have already been used and should be unique
 634          * @return      string          A HTML <select> box with all possible records
 635          */
 636         function renderPossibleRecordsSelector($selItems, $conf, $uniqueIds=array()) {
 637                 $foreign_table = $conf['foreign_table'];
 638                 $foreign_selector = $conf['foreign_selector'];
 639
 640                 $selConfig = $this->getPossibleRecordsSelectorConfig($conf, $foreign_selector);
 641                 $config = $selConfig['PA']['fieldConf']['config'];
 642
 643                 if ($selConfig['type'] == 'select') {
 644                         $item = $this->renderPossibleRecordsSelectorTypeSelect($selItems, $conf, $selConfig['PA'], $uniqueIds);
 645                 } elseif ($selConfig['type'] == 'groupdb') {
 646                         $item = $this->renderPossibleRecordsSelectorTypeGroupDB($conf, $selConfig['PA']);
 647                 }
 648
 649                 return $item;
 650         }
 651
 652
 653         /**
 654          * Get a selector as used for the select type, to select from all available
 655          * records and to create a relation to the embedding record (e.g. like MM).
 656          *
 657          * @param       array           $selItems: Array of all possible records
 658          * @param       array           $conf: TCA configuration of the parent(!) field
 659          * @param       array           $PA: An array with additional configuration options
 660          * @param       array           $uniqueIds: The uids that have already been used and should be unique
 661          * @return      string          A HTML <select> box with all possible records
 662          */
 663         function renderPossibleRecordsSelectorTypeSelect($selItems, $conf, &$PA, $uniqueIds=array()) {
 664                 $foreign_table = $conf['foreign_table'];
 665                 $foreign_selector = $conf['foreign_selector'];
 666
 667                 $PA = array();
 668                 $PA['fieldConf'] = $GLOBALS['TCA'][$foreign_table]['columns'][$foreign_selector];
 669                 $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
 670                 $PA['fieldTSConfig'] = $this->fObj->setTSconfig($foreign_table,array(),$foreign_selector);
 671                 $config = $PA['fieldConf']['config'];
 672
 673                 if(!$disabled) {
 674                                 // Create option tags:
 675                         $opt = array();
 676                         $styleAttrValue = '';
 677                         foreach($selItems as $p)        {
 678                                 if ($config['iconsInOptionTags'])       {
 679                                         $styleAttrValue = $this->fObj->optionTagStyle($p[2]);
 680                                 }
 681                                 if (!in_array($p[1], $uniqueIds)) {
 682                                         $opt[]= '<option value="'.htmlspecialchars($p[1]).'"'.
 683                                                                         ' style="'.(in_array($p[1], $uniqueIds) ? '' : '').
 684                                                                         ($styleAttrValue ? ' style="'.htmlspecialchars($styleAttrValue) : '').'">'.
 685                                                                         htmlspecialchars($p[0]).'</option>';
 686                                 }
 687                         }
 688
 689                                 // Put together the selector box:
 690                         $selector_itemListStyle = isset($config['itemListStyle']) ? ' style="'.htmlspecialchars($config['itemListStyle']).'"' : ' style="'.$this->fObj->defaultMultipleSelectorStyle.'"';
 691                         $size = intval($conf['size']);
 692                         $size = $conf['autoSizeMax'] ? t3lib_div::intInRange(count($itemArray)+1,t3lib_div::intInRange($size,1),$conf['autoSizeMax']) : $size;
 693                         $onChange = "return inline.importNewRecord('".$this->inlineNames['object']."[".$conf['foreign_table']."]')";
 694                         $item = '
 695                                 <select id="'.$this->inlineNames['object'].'['.$conf['foreign_table'].']_selector"'.
 696                                                         $this->fObj->insertDefStyle('select').
 697                                                         ($size ? ' size="'.$size.'"' : '').
 698                                                         ' onchange="'.htmlspecialchars($onChange).'"'.
 699                                                         $PA['onFocus'].
 700                                                         $selector_itemListStyle.
 701                                                         ($conf['foreign_unique'] ? ' isunique="isunique"' : '').'>
 702                                         '.implode('
 703                                         ',$opt).'
 704                                 </select>';
 705
 706                                 // add a "Create new relation" link for adding new relations
 707                                 // this is neccessary, if the size of the selector is "1" or if
 708                                 // there is only one record item in the select-box, that is selected by default
 709                                 // the selector-box creates a new relation on using a onChange event (see some line above)
 710                         $createNewRelationText = $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.php:cm.createNewRelation',1);
 711                         $item .=
 712                                 '<a href="#" onclick="'.htmlspecialchars($onChange).'" align="abstop">'.
 713                                         '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/edit2.gif','width="11" height="12"').' align="absmiddle" '.t3lib_BEfunc::titleAltAttrib($createNewRelationText).' /> '.$createNewRelationText.
 714                                 '</a>';
 715                                 // wrap the selector and add a spacer to the bottom
 716                         $item = '<div style="margin-bottom: 20px;">'.$item.'</div>';
 717                 }
 718
 719                 return $item;
 720         }
 721
 722
 723         /**
 724          * Generate a link that opens an element browser in a new window.
 725          * For group/db there is no way o use a "selector" like a <select>|</select>-box.
 726          *
 727          * @param       array           $conf: TCA configuration of the parent(!) field
 728          * @param       array           $PA: An array with additional configuration options
 729          * @return      string          A HTML link that opens an element browser in a new window
 730          */
 731         function renderPossibleRecordsSelectorTypeGroupDB($conf, &$PA) {
 732                 $foreign_table = $conf['foreign_table'];
 733
 734                 $config = $PA['fieldConf']['config'];
 735                 $allowed = $config['allowed'];
 736                 $objectPrefix = $this->inlineNames['object'].'['.$foreign_table.']';
 737
 738                 $createNewRelationText = $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.php:cm.createNewRelation',1);
 739                 $onClick = "setFormValueOpenBrowser('db','".('|||'.$allowed.'|'.$objectPrefix.'|inline.checkUniqueElement||inline.importElement')."'); return false;";
 740                 $item =
 741                         '<a href="#" onclick="'.htmlspecialchars($onClick).'">'.
 742                                 '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/insert3.gif','width="14" height="14"').' align="absmiddle" '.t3lib_BEfunc::titleAltAttrib($createNewRelationText).' /> '.$createNewRelationText.
 743                         '</a>';
 744
 745                 return $item;
 746         }
 747
 748
 749         /**
 750          * Creates a link/button to create new records
 751          *
 752          * @param       string          $objectPrefix: The "path" to the child record to create (e.g. '[parten_table][parent_uid][parent_field][child_table]')
 753          * @param       array           $conf: TCA configuration of the parent(!) field
 754          * @return      string          The HTML code for the new record link
 755          */
 756         function getNewRecordLink($objectPrefix, $conf = array()) {
 757                 if ($conf['inline']['inlineNewButtonStyle']) $style = ' style="'.$conf['inline']['inlineNewButtonStyle'].'"';
 758
 759                 $onClick = "return inline.createNewRecord('$objectPrefix')";
 760                 $title = $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.php:cm.createnew',1);
 761
 762                 if ($conf['appearance']['newRecordLinkAddTitle'])
 763                         $tableTitle .= ' '.$GLOBALS['LANG']->sL($GLOBALS['TCA'][$conf['foreign_table']]['ctrl']['title'],1);
 764
 765                 $out = '
 766                                 <div class="typo3-newRecordLink">
 767                                         <a href="#" onClick="'.$onClick.'" class="inlineNewButton"'.$style.' title="'.$title.$tableTitle.'">'.
 768                                         '<img'.t3lib_iconWorks::skinImg($this->backPath,'gfx/new_el.gif','width="11" height="12"').' alt="'.$title.$tableTitle.'" />'.
 769                                         $title.t3lib_div::fixed_lgd_cs($tableTitle, $this->fObj->titleLen).
 770                                         '</a>
 771                                 </div>';
 772                 return $out;
 773         }
 774
 775
 776         /**
 777          * Add Sortable functionality using script.acolo.us "Sortable".
 778          *
 779          * @param       string          $objectId: The container id of the object - elements inside will be sortable
 780          * @return      void
 781          */
 782         function addJavaScriptSortable($objectId) {
 783                 $this->fObj->additionalJS_post[] = '
 784                         inline.createDragAndDropSorting("'.$objectId.'");
 785                 ';
 786         }
 787
 788
 789         /*******************************************************
 790          *
 791          * Handling of AJAX calls
 792          *
 793          *******************************************************/
 794
 795
 796         /**
 797          * Initialize environment for AJAX calls
 798          *
 799          * @param       string          $method: Name of the method to be called
 800          * @param       array           $arguments: Arguments to be delivered to the method
 801          * @return      void
 802          */
 803         function initForAJAX($method, &$arguments) {
 804                         // Set t3lib_TCEforms::$RTEcounter to the given value:
 805                 if ($method == 'createNewRecord') {
 806                         $this->fObj->RTEcounter = intval(array_shift($arguments));
 807                 }
 808         }
 809
 810
 811         /**
 812          * Handle AJAX calls to show a new inline-record of the given table.
 813          * Normally this method is never called from inside TYPO3. Always from outside by AJAX.
 814          *
 815          * @param       string          $domObjectId: The calling object in hierarchy, that requested a new record.
 816          * @param       string          $foreignUid: If set, the new record should be inserted after that one.
 817          * @return      string          A JSON string
 818          */
 819         function createNewRecord($domObjectId, $foreignUid = 0) {
 820                 $this->isAjaxCall = true;
 821                         // parse the DOM identifier (string), add the levels to the structure stack (array) and load the TCA config
 822                 $this->parseStructureString($domObjectId, true);
 823                         // the current table - for this table we should add/import records
 824                 $current = $this->inlineStructure['unstable'];
 825                         // the parent table - this table embeds the current table
 826                 $parent = $this->getStructureLevel(-1);
 827                         // get TCA 'config' of the parent table
 828                 $config = $parent['config'];
 829
 830                         // Put the current level also to the dynNestedStack of TCEforms:
 831                 $this->fObj->pushToDynNestedStack('inline', $this->inlineNames['object']);
 832
 833                         // dynamically create a new record using t3lib_transferData
 834                 if (!$foreignUid || !t3lib_div::testInt($foreignUid) || $config['foreign_selector']) {
 835                         $record = $this->getNewRecord($this->inlineFirstPid, $current['table']);
 836
 837                         // dynamically import an existing record (this could be a call from a select box)
 838                 } else {
 839                         $record = $this->getRecord($this->inlineFirstPid, $current['table'], $foreignUid);
 840                 }
 841
 842                         // now there is a foreign_selector, so there is a new record on the intermediate table, but
 843                         // this intermediate table holds a field, which is responsible for the foreign_selector, so
 844                         // we have to set this field to the uid we get - or if none, to a new uid
 845                 if ($config['foreign_selector'] && $foreignUid) {
 846                         $selConfig = $this->getPossibleRecordsSelectorConfig($config, $config['foreign_selector']);
 847                                 // For a selector of type group/db, prepend the tablename (<tablename>_<uid>):
 848                         $record[$config['foreign_selector']] = $selConfig['type'] != 'groupdb' ? '' : $selConfig['table'].'_';
 849                         $record[$config['foreign_selector']] .= $foreignUid;
 850                 }
 851
 852                         // the HTML-object-id's prefix of the dynamically created record
 853                 $objectPrefix = $this->inlineNames['object'].'['.$current['table'].']';
 854                 $objectId = $objectPrefix.'['.$record['uid'].']';
 855
 856                         // render the foreign record that should passed back to browser
 857                 $item = $this->renderForeignRecord($parent['uid'], $record, $config);
 858                 if($item === false) {
 859                         $jsonArray = array(
 860                                 'data'  => 'Access denied',
 861                                 'scriptCall' => array(
 862                                         "alert('Access denied');",
 863                                 )
 864                         );
 865                         return t3lib_div::array2json($jsonArray);
 866                 }
 867
 868                         // Encode TCEforms AJAX response with utf-8:
 869                 $item = $GLOBALS['LANG']->csConvObj->utf8_encode($item, $GLOBALS['LANG']->charSet);
 870
 871                 if (!$current['uid']) {
 872                         $jsonArray = array(
 873                                 'data'  => $item,
 874                                 'scriptCall' => array(
 875                                         "inline.domAddNewRecord('bottom','".$this->inlineNames['object']."_records','$objectPrefix',json.data);",
 876                                         "inline.memorizeAddRecord('$objectPrefix','".$record['uid']."',null,'$foreignUid');"
 877                                 )
 878                         );
 879
 880                         // append the HTML data after an existing record in the container
 881                 } else {
 882                         $jsonArray = array(
 883                                 'data'  => $item,
 884                                 'scriptCall' => array(
 885                                         "inline.domAddNewRecord('after','".$domObjectId.'_div'."','$objectPrefix',json.data);",
 886                                         "inline.memorizeAddRecord('$objectPrefix','".$record['uid']."','".$current['uid']."','$foreignUid');"
 887                                 )
 888                         );
 889                 }
 890
 891                         // add the JavaScript data that would have been added at the bottom of a regular TCEforms calls
 892                 $jsonArray['scriptCall'][] = $this->fObj->JSbottom($this->fObj->formName, true);
 893                         // if script.aculo.us Sortable is used, update the Observer to know the the record
 894                 if ($config['appearance']['useSortable'])
 895                         $jsonArray['scriptCall'][] = "inline.createDragAndDropSorting('".$this->inlineNames['object']."_records');";
 896                         // if TCEforms has some JavaScript code to be executed, just do it
 897                 if ($this->fObj->extJSCODE)
 898                         $jsonArray['scriptCall'][] = $this->fObj->extJSCODE;
 899                         // tell the browser to scroll to the newly created record
 900                 $jsonArray['scriptCall'][] = "Element.scrollTo('".$objectId."_div');";
 901                         // fade out and fade in the new record in the browser view to catch the user's eye
 902                 $jsonArray['scriptCall'][] = "inline.fadeOutFadeIn('".$objectId."_div');";
 903
 904                         // Remove the current level also from the dynNestedStack of TCEforms:
 905                 $this->fObj->popFromDynNestedStack();
 906
 907                         // return the JSON string
 908                 return t3lib_div::array2json($jsonArray);
 909         }
 910
 911
 912         /**
 913          * Save the expanded/collapsed state of a child record in the BE_USER->uc.
 914          *
 915          * @param       string          $domObjectId: The calling object in hierarchy, that requested a new record.
 916          * @param       string          $expand: Whether this record is expanded.
 917          * @param       string          $collapse: Whether this record is collapsed.
 918          * @return      void
 919          */
 920         function setExpandedCollapsedState($domObjectId, $expand, $collapse) {
 921                         // parse the DOM identifier (string), add the levels to the structure stack (array), but don't load TCA config
 922                 $this->parseStructureString($domObjectId, false);
 923                         // the current table - for this table we should add/import records
 924                 $current = $this->inlineStructure['unstable'];
 925                         // the top parent table - this table embeds the current table
 926                 $top = $this->getStructureLevel(0);
 927
 928                         // only do some action if the top record and the current record were saved before
 929                 if (t3lib_div::testInt($top['uid'])) {
 930                         $inlineView = unserialize($GLOBALS['BE_USER']->uc['inlineView']);
 931                         $inlineViewCurrent =& $inlineView[$top['table']][$top['uid']];
 932
 933                         $expandUids = t3lib_div::trimExplode(',', $expand);
 934                         $collapseUids = t3lib_div::trimExplode(',', $collapse);
 935
 936                                 // set records to be expanded
 937                         foreach ($expandUids as $uid) {
 938                                 $inlineViewCurrent[$current['table']][] = $uid;
 939                         }
 940                                 // set records to be collapsed
 941                         foreach ($collapseUids as $uid) {
 942                                 $inlineViewCurrent[$current['table']] = $this->removeFromArray($uid, $inlineViewCurrent[$current['table']]);
 943                         }
 944
 945                                 // save states back to database
 946                         if (is_array($inlineViewCurrent[$current['table']])) {
 947                                 $GLOBALS['BE_USER']->uc['inlineView'] = serialize($inlineView);
 948                                 $GLOBALS['BE_USER']->writeUC();
 949                         }
 950                 }
 951         }
 952
 953
 954         /*******************************************************
 955          *
 956          * Get data from database and handle relations
 957          *
 958          *******************************************************/
 959
 960
 961         /**
 962          * Get the related records of the embedding item, this could be 1:n, m:n.
 963          *
 964          * @param       string          $table: The table name of the record
 965          * @param       string          $field: The field name which this element is supposed to edit
 966          * @param       array           $row: The record data array where the value(s) for the field can be found
 967          * @param       array           $PA: An array with additional configuration options.
 968          * @param       array           $config: (Redundant) content of $PA['fieldConf']['config'] (for convenience)
 969          * @return      array           The records related to the parent item
 970          */
 971         function getRelatedRecords($table,$field,$row,&$PA,$config) {
 972                 $records = array();
 973
 974                         // Creating the label for the "No Matching Value" entry.
 975                 $nMV_label = isset($PA['fieldTSConfig']['noMatchingValue_label']) ? $this->fObj->sL($PA['fieldTSConfig']['noMatchingValue_label']) : '[ '.$this->fObj->getLL('l_noMatchingValue').' ]';
 976
 977                         // Register the required number of elements:
 978                 # $this->fObj->requiredElements[$PA['itemFormElName']] = array($minitems,$maxitems,'imgName'=>$table.'_'.$row['uid'].'_'.$field);
 979
 980                         // Perform modification of the selected items array:
 981                 $itemArray = t3lib_div::trimExplode(',',$PA['itemFormElValue'],1);
 982                 foreach($itemArray as $tk => $tv) {
 983                         $tvP = explode('|',$tv,2);
 984                                 // get the records for this uid using t3lib_transferdata
 985                         $records[] = $this->getRecord($row['pid'], $config['foreign_table'], $tvP[0]);
 986                 }
 987
 988                 return $records;
 989         }
 990
 991
 992         /**
 993          * Get possible records.
 994          * Copied from TCEform and modified.
 995          *
 996          * @param       string          The table name of the record
 997          * @param       string          The field name which this element is supposed to edit
 998          * @param       array           The record data array where the value(s) for the field can be found
 999          * @param       array           An array with additional configuration options.
1000          * @param       string          $checkForConfField: For which field in the foreign_table the possible records should be fetched
1001          * @return      mixed           Array of possible record items; false if type is "group/db", then everything could be "possible"
1002          */
1003         function getPossibleRecords($table,$field,$row,$conf,$checkForConfField='foreign_selector') {
1004                         // ctrl configuration from TCA:
1005                 $tcaTableCtrl = $GLOBALS['TCA'][$table]['ctrl'];
1006                         // Field configuration from TCA:
1007                 $foreign_table = $conf['foreign_table'];
1008                 $foreign_check = $conf[$checkForConfField];
1009
1010                 $foreignConfig = $this->getPossibleRecordsSelectorConfig($conf, $foreign_check);
1011                 $PA = $foreignConfig['PA'];
1012                 $config = $PA['fieldConf']['config'];
1013
1014                 if ($foreignConfig['type'] == 'select') {
1015                                 // Getting the selector box items from the system
1016                         $selItems = $this->fObj->addSelectOptionsToItemArray($this->fObj->initItemArray($PA['fieldConf']),$PA['fieldConf'],$this->fObj->setTSconfig($table,$row),$field);
1017                         if ($config['itemsProcFunc']) $selItems = $this->fObj->procItems($selItems,$PA['fieldTSConfig']['itemsProcFunc.'],$config,$table,$row,$field);
1018
1019                                 // Possibly remove some items:
1020                         $removeItems = t3lib_div::trimExplode(',',$PA['fieldTSConfig']['removeItems'],1);
1021                         foreach($selItems as $tk => $p) {
1022
1023                                         // Checking languages and authMode:
1024                                 $languageDeny = $tcaTableCtrl['languageField'] && !strcmp($tcaTableCtrl['languageField'], $field) && !$GLOBALS['BE_USER']->checkLanguageAccess($p[1]);
1025                                 $authModeDeny = $config['form_type']=='select' && $config['authMode'] && !$GLOBALS['BE_USER']->checkAuthMode($table,$field,$p[1],$config['authMode']);
1026                                 if (in_array($p[1],$removeItems) || $languageDeny || $authModeDeny)     {
1027                                         unset($selItems[$tk]);
1028                                 } elseif (isset($PA['fieldTSConfig']['altLabels.'][$p[1]])) {
1029                                         $selItems[$tk][0]=$this->fObj->sL($PA['fieldTSConfig']['altLabels.'][$p[1]]);
1030                                 }
1031
1032                                         // Removing doktypes with no access:
1033                                 if ($table.'.'.$field == 'pages.doktype')       {
1034                                         if (!($GLOBALS['BE_USER']->isAdmin() || t3lib_div::inList($GLOBALS['BE_USER']->groupData['pagetypes_select'],$p[1])))   {
1035                                                 unset($selItems[$tk]);
1036                                         }
1037                                 }
1038                         }
1039                 } else {
1040                         $selItems = false;
1041                 }
1042
1043                 return $selItems;
1044         }
1045
1046         /**
1047          * Gets the uids of a select/selector that should be unique an have already been used.
1048          *
1049          * @param       array           $records: All inline records on this level
1050          * @param       array           $conf: The TCA field configuration of the inline field to be rendered
1051          * @param       boolean         $splitValue: for usage with group/db, values come like "tx_table_123|Title%20abc", but we need "tx_table" and "123"
1052          * @return      array           The uids, that have been used already and should be used unique
1053          */
1054         function getUniqueIds($records, $conf=array(), $splitValue=false) {
1055                 $uniqueIds = array();
1056
1057                 if ($conf['foreign_unique'] && count($records)) {
1058                         foreach ($records as $rec) {
1059                                 $value = $rec[$conf['foreign_unique']];
1060                                         // Split the value and extract the table and uid:
1061                                 if ($splitValue) {
1062                                         $valueParts = t3lib_div::trimExplode('|', $value);
1063                                         $itemParts = explode('_', $valueParts[0]);
1064                                         $value = array(
1065                                                 'uid' => array_pop($itemParts),
1066                                                 'table' => implode('_', $itemParts)
1067                                         );
1068                                 }
1069                                 $uniqueIds[$rec['uid']] = $value;
1070                         }
1071                 }
1072
1073                 return $uniqueIds;
1074         }
1075
1076
1077         /**
1078          * Get a single record row for a TCA table from the database.
1079          * t3lib_transferData is used for "upgrading" the values, especially the relations.
1080          *
1081          * @param       integer         $pid: The pid of the page the record should be stored (only relevant for NEW records)
1082          * @param       string          $table: The table to fetch data from (= foreign_table)
1083          * @param       string          $uid: The uid of the record to fetch, or the pid if a new record should be created
1084          * @param       string          $cmd: The command to perform, empty or 'new'
1085          * @return      array           A record row from the database post-processed by t3lib_transferData
1086          */
1087         function getRecord($pid, $table, $uid, $cmd='') {
1088                 $trData = t3lib_div::makeInstance('t3lib_transferData');
1089                 $trData->addRawData = TRUE;
1090                 # $trData->defVals = $this->defVals;
1091                 $trData->lockRecords=1;
1092                 $trData->disableRTE = $GLOBALS['SOBE']->MOD_SETTINGS['disableRTE'];
1093                         // if a new record should be created
1094                 $trData->fetchRecord($table, $uid, ($cmd === 'new' ? 'new' : ''));
1095                 reset($trData->regTableItems_data);
1096                 $rec = current($trData->regTableItems_data);
1097                 $rec['uid'] = $cmd == 'new' ? uniqid('NEW') : $uid;
1098                 if ($cmd=='new') $rec['pid'] = $pid;
1099
1100                 return $rec;
1101         }
1102
1103
1104         /**
1105          * Wrapper. Calls getRecord in case of a new record should be created.
1106          *
1107          * @param       integer         $pid: The pid of the page the record should be stored (only relevant for NEW records)
1108          * @param       string          $table: The table to fetch data from (= foreign_table)
1109          * @return      array           A record row from the database post-processed by t3lib_transferData
1110          */
1111         function getNewRecord($pid, $table) {
1112                 return $this->getRecord($pid, $table, $pid, 'new');
1113         }
1114
1115
1116         /*******************************************************
1117          *
1118          * Structure stack for handling inline objects/levels
1119          *
1120          *******************************************************/
1121
1122
1123         /**
1124          * Add a new level on top of the structure stack. Other functions can access the
1125          * stack and determine, if there's possibly a endless loop.
1126          *
1127          * @param       string          $table: The table name of the record
1128          * @param       string          $uid: The uid of the record that embeds the inline data
1129          * @param       string          $field: The field name which this element is supposed to edit
1130          * @param       array           $config: The TCA-configuration of the inline field
1131          * @return      void
1132          */
1133         function pushStructure($table, $uid, $field = '', $config = array()) {
1134                 $this->inlineStructure['stable'][] = array(
1135                         'table' => $table,
1136                         'uid' => $uid,
1137                         'field' => $field,
1138                         'config' => $config,
1139                 );
1140                 $this->updateStructureNames();
1141         }
1142
1143
1144         /**
1145          * Remove the item on top of the structure stack and return it.
1146          *
1147          * @return      array           The top item of the structure stack - array(<table>,<uid>,<field>,<config>)
1148          */
1149         function popStructure() {
1150                 if (count($this->inlineStructure['stable'])) {
1151                         $popItem = array_pop($this->inlineStructure['stable']);
1152                         $this->updateStructureNames();
1153                 }
1154                 return $popItem;
1155         }
1156
1157
1158         /**
1159          * For common use of DOM object-ids and form field names of a several inline-level,
1160          * these names/identifiers are preprocessed and set to $this->inlineNames.
1161          * This function is automatically called if a level is pushed to or removed from the
1162          * inline structure stack.
1163          *
1164          * @return      void
1165          */
1166         function updateStructureNames() {
1167                 $current = $this->getStructureLevel(-1);
1168                         // if there are still more inline levels available
1169                 if ($current !== false) {
1170                         $lastItemName = $this->getStructureItemName($current);
1171                         $this->inlineNames = array(
1172                                 'form' => $this->prependFormFieldNames.$lastItemName,
1173                                 'object' => $this->prependNaming.'['.$this->inlineFirstPid.']'.$this->getStructurePath(),
1174                         );
1175                         // if there are no more inline levels available
1176                 } else {
1177                         $this->inlineNames = array();
1178                 }
1179         }
1180
1181
1182         /**
1183          * Create a name/id for usage in HTML output of a level of the structure stack.
1184          *
1185          * @param       array           $levelData: Array of a level of the structure stack (containing the keys table, uid and field)
1186          * @return      string          The name/id of that level, to be used for HTML output
1187          */
1188         function getStructureItemName($levelData) {
1189                 if (is_array($levelData)) {
1190                         $name = '['.$levelData['table'].']' .
1191                                         '['.$levelData['uid'].']' .
1192                                         (isset($levelData['field']) ? '['.$levelData['field'].']' : '');
1193                 }
1194                 return $name;
1195         }
1196
1197
1198         /**
1199          * Get a level from the stack and return the data.
1200          * If the $level value is negative, this function works top-down,
1201          * if the $level value is positive, this function works bottom-up.
1202          *
1203          * @param       integer         $level: Which level to return
1204          * @return      array           The item of the stack at the requested level
1205          */
1206         function getStructureLevel($level) {
1207                 $inlineStructureCount = count($this->inlineStructure['stable']);
1208                 if ($level < 0) $level = $inlineStructureCount+$level;
1209                 if ($level >= 0 && $level < $inlineStructureCount)
1210                         return $this->inlineStructure['stable'][$level];
1211                 else
1212                         return false;
1213         }
1214
1215
1216         /**
1217          * Get the identifiers of a given depth of level, from the top of the stack to the bottom.
1218          * An identifier consists looks like [<table>][<uid>][<field>].
1219          *
1220          * @param       integer         $structureDepth: How much levels to output, beginning from the top of the stack
1221          * @return      string          The path of identifiers
1222          */
1223         function getStructurePath($structureDepth = -1) {
1224                 $structureCount = count($this->inlineStructure['stable']);
1225                 if ($structureDepth < 0 || $structureDepth > $structureCount) $structureDepth = $structureCount;
1226
1227                 for ($i = 1; $i <= $structureDepth; $i++) {
1228                         $current = $this->getStructureLevel(-$i);
1229                         $string = $this->getStructureItemName($current).$string;
1230                 }
1231
1232                 return $string;
1233         }
1234
1235
1236         /**
1237          * Convert the DOM object-id of an inline container to an array.
1238          * The object-id could look like 'data[inline][tx_mmftest_company][1][employees]'.
1239          * The result is written to $this->inlineStructure.
1240          * There are two keys:
1241          *  - 'stable': Containing full qualified identifiers (table, uid and field)
1242          *  - 'unstable': Containting partly filled data (e.g. only table and possibly field)
1243          *
1244          * @param       string          $domObjectId: The DOM object-id
1245          * @param       boolean         $loadConfig: Load the TCA configuration for that level
1246          * @return      void
1247          */
1248         function parseStructureString($string, $loadConfig = false) {
1249                 $unstable = array();
1250                 $vector = array('table', 'uid', 'field');
1251                 $pattern = '/^'.$this->prependNaming.'\[(.+?)\]\[(.+)\]$/';
1252                 if (preg_match($pattern, $string, $match)) {
1253                         $this->inlineFirstPid = $match[1];
1254                         $parts = explode('][', $match[2]);
1255                         $partsCnt = count($parts);
1256                         for ($i = 0; $i < $partsCnt; $i++) {
1257                                 if ($i > 0 && $i % 3 == 0) {
1258                                                 // load the TCA configuration of the table field and store it in the stack
1259                                         if ($loadConfig) {
1260                                                 t3lib_div::loadTCA($unstable['table']);
1261                                                 $unstable['config'] = $GLOBALS['TCA'][$unstable['table']]['columns'][$unstable['field']]['config'];
1262                                                         // Fetch TSconfig:
1263                                                 $TSconfig = $this->fObj->setTSconfig(
1264                                                         $unstable['table'],
1265                                                         array('uid' => $unstable['uid'], 'pid' => $this->inlineFirstPid),
1266                                                         $unstable['field']
1267                                                 );
1268                                                         // Override TCA field config by TSconfig:
1269                                                 if (!$TSconfig['disabled']) {
1270                                                         $unstable['config'] = $this->fObj->overrideFieldConf($unstable['config'], $TSconfig);
1271                                                 }
1272                                         }
1273                                         $this->inlineStructure['stable'][] = $unstable;
1274                                         $unstable = array();
1275                                 }
1276                                 $unstable[$vector[$i % 3]] = $parts[$i];
1277                         }
1278                         $this->updateStructureNames();
1279                         if (count($unstable)) $this->inlineStructure['unstable'] = $unstable;
1280                 }
1281         }
1282
1283
1284         /*******************************************************
1285          *
1286          * Helper functions
1287          *
1288          *******************************************************/
1289
1290
1291         /**
1292          * Does some checks on the TCA configuration of the inline field to render.
1293          *
1294          * @param       array           $config: Reference to the TCA field configuration
1295          * @return      boolean         If critical configuration errors were found, false is returned
1296          */
1297         function checkConfiguration(&$config) {
1298                 $foreign_table = $config['foreign_table'];
1299
1300                         // An inline field must have a foreign_table, if not, stop all further inline actions for this field:
1301                 if (!$foreign_table || !is_array($GLOBALS['TCA'][$foreign_table])) {
1302                         return false;
1303                 }
1304                         // Init appearance if not set:
1305                 if (!is_array($config['appearance'])) {
1306                         $config['appearance'] = array();
1307                 }
1308                         // Set the position/appearance of the "Create new record" link:
1309                 if ($config['foreign_selector'] && !$config['appearance']['useCombination']) {
1310                         $config['appearance']['newRecordLinkPosition'] = 'none';
1311                 } elseif (!in_array($config['appearance']['newRecordLinkPosition'], array('top', 'bottom', 'both', 'none'))) {
1312                         $config['appearance']['newRecordLinkPosition'] = 'top';
1313                 }
1314
1315                 return true;
1316         }
1317
1318
1319         /**
1320          * Checks the page access rights (Code for access check mostly taken from alt_doc.php)
1321          * as well as the table access rights of the user.
1322          *
1323          * @param       string          $cmd: The command that sould be performed ('new' or 'edit')
1324          * @param       string          $table: The table to check access for
1325          * @param       string          $theUid: The record uid of the table
1326          * @return      boolean         Returns true is the user has access, or false if not
1327          */
1328         function checkAccess($cmd, $table, $theUid) {
1329                         // Checking if the user has permissions? (Only working as a precaution, because the final permission check is always down in TCE. But it's good to notify the user on beforehand...)
1330                         // First, resetting flags.
1331                 $hasAccess = 0;
1332                 $deniedAccessReason = '';
1333
1334                         // If the command is to create a NEW record...:
1335                 if ($cmd=='new') {
1336                                 // If the pid is numerical, check if it's possible to write to this page:
1337                         if (t3lib_div::testInt($this->inlineFirstPid)) {
1338                                 $calcPRec = t3lib_BEfunc::getRecord('pages', $this->inlineFirstPid);
1339                                 if(!is_array($calcPRec)) {
1340                                         return false;
1341                                 }
1342                                 $CALC_PERMS = $GLOBALS['BE_USER']->calcPerms($calcPRec);        // Permissions for the parent page
1343                                 if ($table=='pages')    {       // If pages:
1344                                         $hasAccess = $CALC_PERMS&8 ? 1 : 0; // Are we allowed to create new subpages?
1345                                 } else {
1346                                         $hasAccess = $CALC_PERMS&16 ? 1 : 0; // Are we allowed to edit content on this page?
1347                                 }
1348                                 // If the pid is a NEW... value, the access will be checked on creating the page:
1349                                 // (if the page with the same NEW... value could be created in TCEmain, this child record can neither)
1350                         } else {
1351                                 $hasAccess = 1;
1352                         }
1353                 } else {        // Edit:
1354                         $calcPRec = t3lib_BEfunc::getRecord($table,$theUid);
1355                         t3lib_BEfunc::fixVersioningPid($table,$calcPRec);
1356                         if (is_array($calcPRec))        {
1357                                 if ($table=='pages')    {       // If pages:
1358                                         $CALC_PERMS = $GLOBALS['BE_USER']->calcPerms($calcPRec);
1359                                         $hasAccess = $CALC_PERMS&2 ? 1 : 0;
1360                                 } else {
1361                                         $CALC_PERMS = $GLOBALS['BE_USER']->calcPerms(t3lib_BEfunc::getRecord('pages',$calcPRec['pid']));        // Fetching pid-record first.
1362                                         $hasAccess = $CALC_PERMS&16 ? 1 : 0;
1363                                 }
1364
1365                                         // Check internals regarding access:
1366                                 if ($hasAccess) {
1367                                         $hasAccess = $GLOBALS['BE_USER']->recordEditAccessInternals($table, $calcPRec);
1368                                 }
1369                         }
1370                 }
1371
1372                 if(!$GLOBALS['BE_USER']->check('tables_modify', $table)) {
1373                         $hasAccess = 0;
1374                 }
1375
1376                 if(!$hasAccess) {
1377                         $deniedAccessReason = $GLOBALS['BE_USER']->errorMsg;
1378                         if($deniedAccessReason) {
1379                                 debug($deniedAccessReason);
1380                         }
1381                 }
1382
1383                 return $hasAccess ? true : false;
1384         }
1385
1386
1387         /**
1388          * Check the keys and values in the $compare array against the ['config'] part of the top level of the stack.
1389          * A boolean value is return depending on how the comparison was successful.
1390          *
1391          * @param       array           $compare: keys and values to compare to the ['config'] part of the top level of the stack
1392          * @return      boolean         Whether the comparison was successful
1393          * @see         arrayCompareComplex
1394          */
1395         function compareStructureConfiguration($compare) {
1396                 $level = $this->getStructureLevel(-1);
1397                 $result = $this->arrayCompareComplex($level, $compare);
1398
1399                 return $result;
1400         }
1401
1402
1403         /**
1404          * Normalize a relation "uid" published by transferData, like "1|Company%201"
1405          *
1406          * @param       string          $string: A transferData reference string, containing the uid
1407          * @return      string          The normalized uid
1408          */
1409         function normalizeUid($string) {
1410                 $parts = explode('|', $string);
1411                 return $parts[0];
1412         }
1413
1414
1415         /**
1416          * Wrap the HTML code of a section with a table tag.
1417          *
1418          * @param       string          $section: The HTML code to be wrapped
1419          * @param       array           $styleAttrs: Attributes for the style argument in the table tag
1420          * @param       array           $tableAttrs: Attributes for the table tag (like width, border, etc.)
1421          * @return      string          The wrapped HTML code
1422          */
1423         function wrapFormsSection($section, $styleAttrs = array(), $tableAttrs = array()) {
1424                 if (!$styleAttrs['margin-right']) $styleAttrs['margin-right'] = $this->inlineStyles['margin-right'].'px';
1425
1426                 foreach ($styleAttrs as $key => $value) $style .= ($style?' ':'').$key.': '.htmlspecialchars($value).'; ';
1427                 if ($style) $style = ' style="'.$style.'"';
1428
1429                 if (!$tableAttrs['background'] && $this->fObj->borderStyle[2]) $tableAttrs['background'] = $this->backPath.$this->borderStyle[2];
1430                 if (!$tableAttrs['cellspacing']) $tableAttrs['cellspacing'] = '0';
1431                 if (!$tableAttrs['cellpadding']) $tableAttrs['cellpadding'] = '0';
1432                 if (!$tableAttrs['border']) $tableAttrs['border'] = '0';
1433                 if (!$tableAttrs['width']) $tableAttrs['width'] = '100%';
1434                 if (!$tableAttrs['class'] && $this->borderStyle[3]) $tableAttrs['class'] = $this->borderStyle[3];
1435
1436                 foreach ($tableAttrs as $key => $value) $table .= ($table?' ':'').$key.'="'.htmlspecialchars($value).'"';
1437
1438                 $out = '<table '.$table.$style.'>'.$section.'</table>';
1439                 return $out;
1440         }
1441
1442
1443         /**
1444          * Checks if the $table is the child of a inline type AND the $field is the label field of this table.
1445          * This function is used to dynamically update the label while editing. This has no effect on labels,
1446          * that were processed by a TCEmain-hook on saving.
1447          *
1448          * @param       string          $table: The table to check
1449          * @param       string          $field: The field on this table to check
1450          * @return      boolean         is inline child and field is responsible for the label
1451          */
1452         function isInlineChildAndLabelField($table, $field) {
1453                 $level = $this->getStructureLevel(-1);
1454                 if ($level['config']['foreign_label'])
1455                         $label = $level['config']['foreign_label'];
1456                 else
1457                         $label = $GLOBALS['TCA'][$table]['ctrl']['label'];
1458                 return $level['config']['foreign_table'] === $table && $label == $field ? true : false;
1459         }
1460
1461
1462         /**
1463          * Get the depth of the stable structure stack.
1464          * (count($this->inlineStructure['stable'])
1465          *
1466          * @return      integer         The depth of the structure stack
1467          */
1468         function getStructureDepth() {
1469                 return count($this->inlineStructure['stable']);
1470         }
1471
1472
1473         /**
1474          * Handles complex comparison requests on an array.
1475          * A request could look like the following:
1476          *
1477          * $searchArray = array(
1478          *              '%AND'  => array(
1479          *                      'key1'  => 'value1',
1480          *                      'key2'  => 'value2',
1481          *                      '%OR'   => array(
1482          *                              'subarray' => array(
1483          *                                      'subkey' => 'subvalue'
1484          *                              ),
1485          *                              'key3'  => 'value3',
1486          *                              'key4'  => 'value4'
1487          *                      )
1488          *              )
1489          * );
1490          *
1491          * It is possible to use the array keys '%AND.1', '%AND.2', etc. to prevent
1492          * overwriting the sub-array. It could be neccessary, if you use complex comparisons.
1493          *
1494          * The example above means, key1 *AND* key2 (and their values) have to match with
1495          * the $subjectArray and additional one *OR* key3 or key4 have to meet the same
1496          * condition.
1497          * It is also possible to compare parts of a sub-array (e.g. "subarray"), so this
1498          * function recurses down one level in that sub-array.
1499          *
1500          * @param       array           $subjectArray: The array to search in
1501          * @param       array           $searchArray: The array with keys and values to search for
1502          * @param       string          $type: Use '%AND' or '%OR' for comparision
1503          * @return      boolean         The result of the comparison
1504          */
1505         function arrayCompareComplex($subjectArray, $searchArray, $type = '') {
1506                 $localMatches = 0;
1507                 $localEntries = 0;
1508
1509                 if (is_array($searchArray) && count($searchArray)) {
1510                                 // if no type was passed, try to determine
1511                         if (!$type) {
1512                                 reset($searchArray);
1513                                 $type = key($searchArray);
1514                                 $searchArray = current($searchArray);
1515                         }
1516
1517                                 // we use '%AND' and '%OR' in uppercase
1518                         $type = strtoupper($type);
1519
1520                                 // split regular elements from sub elements
1521                         foreach ($searchArray as $key => $value) {
1522                                 $localEntries++;
1523
1524                                         // process a sub-group of OR-conditions
1525                                 if ($key == '%OR') {
1526                                         $localMatches += $this->arrayCompareComplex($subjectArray, $value, '%OR') ? 1 : 0;
1527                                         // process a sub-group of AND-conditions
1528                                 } elseif ($key == '%AND') {
1529                                         $localMatches += $this->arrayCompareComplex($subjectArray, $value, '%AND') ? 1 : 0;
1530                                         // a part of an associative array should be compared, so step down in the array hierarchy
1531                                 } elseif (is_array($value) && $this->isAssociativeArray($searchArray)) {
1532                                         $localMatches += $this->arrayCompareComplex($subjectArray[$key], $value, $type) ? 1 : 0;
1533                                         // it is a normal array that is only used for grouping and indexing
1534                                 } elseif (is_array($value)) {
1535                                         $localMatches += $this->arrayCompareComplex($subjectArray, $value, $type) ? 1 : 0;
1536                                         // directly compare a value
1537                                 } else {
1538                                         if (isset($subjectArray[$key]) && isset($value)) {
1539                                                         // Boolean match:
1540                                                 if (is_bool($value)) {
1541                                                         $localMatches += (!($subjectArray[$key] xor $value) ? 1 : 0);
1542                                                         // Value match for numbers:
1543                                                 } elseif (is_numeric($subjectArray[$key]) && is_numeric($value)) {
1544                                                         $localMatches += ($subjectArray[$key] == $value ? 1 : 0);
1545                                                         // Value and type match:
1546                                                 } else {
1547                                                         $localMatches += ($subjectArray[$key] === $value ? 1 : 0);
1548                                                 }
1549                                         }
1550                                 }
1551
1552                                         // if one or more matches are required ('OR'), return true after the first successful match
1553                                 if ($type == '%OR' && $localMatches > 0) return true;
1554                                         // if all matches are required ('AND') and we have no result after the first run, return false
1555                                 if ($type == '%AND' && $localMatches == 0) return false;
1556                         }
1557                 }
1558
1559                         // return the result for '%AND' (if nothing was checked, true is returned)
1560                 return $localEntries == $localMatches ? true : false;
1561         }
1562
1563
1564         /**
1565          * Checks whether an object is an associative array.
1566          *
1567          * @param       mixed           $object: The object to be checked
1568          * @return      boolean         Returns true, if the object is an associative array
1569          */
1570         function isAssociativeArray($object) {
1571                 return is_array($object) && count($object) && (array_keys($object) !== range(0, sizeof($object) - 1))
1572                         ? true
1573                         : false;
1574         }
1575
1576
1577         /**
1578          * Remove an element from an array.
1579          *
1580          * @param       mixed           $needle: The element to be removed.
1581          * @param       array           $haystack: The array the element should be removed from.
1582          * @param       mixed           $strict: Search elements strictly.
1583          * @return      array           The array $haystack without the $needle
1584          */
1585         function removeFromArray($needle, $haystack, $strict=null) {
1586                 $pos = array_search($needle, $haystack, $strict);
1587                 if ($pos !== false) unset($haystack[$pos]);
1588                 return $haystack;
1589         }
1590
1591
1592         /**
1593          * Makes a flat array from the $possibleRecords array.
1594          * The key of the flat array is the value of the record,
1595          * the value of the flat array is the label of the record.
1596          *
1597          * @param       array           $possibleRecords: The possibleRecords array (for select fields)
1598          * @return      mixed           A flat array with key=uid, value=label; if $possibleRecords isn't an array, false is returned.
1599          */
1600         function getPossibleRecordsFlat($possibleRecords) {
1601                 $flat = false;
1602                 if (is_array($possibleRecords)) {
1603                         $flat = array();
1604                         foreach ($possibleRecords as $record) $flat[$record[1]] = $record[0];
1605                 }
1606                 return $flat;
1607         }
1608
1609
1610         /**
1611          * Determine the configuration and the type of a record selector.
1612          *
1613          * @param       array           $conf: TCA configuration of the parent(!) field
1614          * @return      array           Associative array with the keys 'PA' and 'type', both are false if the selector was not valid.
1615          */
1616         function getPossibleRecordsSelectorConfig($conf, $field = '') {
1617                 $foreign_table = $conf['foreign_table'];
1618                 $foreign_selector = $conf['foreign_selector'];
1619
1620                 $PA = false;
1621                 $type = false;
1622                 $table = false;
1623                 $selector = false;
1624
1625                 if ($field) {
1626                         $PA = array();
1627                         $PA['fieldConf'] = $GLOBALS['TCA'][$foreign_table]['columns'][$field];
1628                         $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
1629                         $PA['fieldTSConfig'] = $this->fObj->setTSconfig($foreign_table,array(),$field);
1630                         $config = $PA['fieldConf']['config'];
1631                                 // Determine type of Selector:
1632                         $type = $this->getPossibleRecordsSelectorType($config);
1633                                 // Return table on this level:
1634                         $table = $type == 'select' ? $config['foreign_table'] : $config['allowed'];
1635                                 // Return type of the selector if foreign_selector is defined and points to the same field as in $field:
1636                         if ($foreign_selector && $foreign_selector == $field && $type) {
1637                                 $selector = $type;
1638                         }
1639                 }
1640
1641                 return array(
1642                         'PA' => $PA,
1643                         'type' => $type,
1644                         'table' => $table,
1645                         'selector' => $selector,
1646                 );
1647         }
1648
1649
1650         /**
1651          * Determine the type of a record selector, e.g. select or group/db.
1652          *
1653          * @param       array           $config: TCE configuration of the selector
1654          * @return      mixed           The type of the selector, 'select' or 'groupdb' - false not valid
1655          */
1656         function getPossibleRecordsSelectorType($config) {
1657                 $type = false;
1658                 if ($config['type'] == 'select') {
1659                         $type = 'select';
1660                 } elseif ($config['type'] == 'group' && $config['internal_type'] == 'db') {
1661                         $type = 'groupdb';
1662                 }
1663                 return $type;
1664         }
1665
1666
1667         /**
1668          * Check, if a field should be skipped, that was defined to be handled as foreign_field or foreign_sortby of
1669          * the parent record of the "inline"-type - if so, we have to skip this field - the rendering is done via "inline" as hidden field
1670          *
1671          * @param       string          $table: The table name
1672          * @param       string          $field: The field name
1673          * @param       array           $row: The record row from the database
1674          * @param       array           $config: TCA configuration of the field
1675          * @return      boolean         Determines whether the field should be skipped.
1676          */
1677         function skipField($table, $field, $row, $config) {
1678                 $skipThisField = false;
1679
1680                 if ($this->getStructureDepth()) {
1681                         $searchArray = array(
1682                                 '%OR' => array(
1683                                         'config' => array(
1684                                                 0 => array(
1685                                                         '%AND' => array(
1686                                                                 'foreign_table' => $table,
1687                                                                 '%OR' => array(
1688                                                                         '%AND' => array(
1689                                                                                 'appearance' => array('useCombination' => true),
1690                                                                                 'foreign_selector' => $field,
1691                                                                         ),
1692                                                                         'MM' => $config['MM']
1693                                                                 ),
1694                                                         ),
1695                                                 ),
1696                                                 1 => array(
1697                                                         '%AND' => array(
1698                                                                 'foreign_table' => $config['foreign_table'],
1699                                                                 'foreign_selector' => $config['foreign_field'],
1700                                                         ),
1701                                                 ),
1702                                         ),
1703                                 ),
1704                         );
1705
1706                                 // get the parent record from structure stack
1707                         $level = $this->getStructureLevel(-1);
1708
1709                                 // If we have symmetric fields, check on which side we are and hide fields, that are set automatically:
1710                         if (t3lib_loadDBGroup::isOnSymmetricSide($level['uid'], $level['config'], $row)) {
1711                                 $searchArray['%OR']['config'][0]['%AND']['%OR']['symmetric_field'] = $field;
1712                                 $searchArray['%OR']['config'][0]['%AND']['%OR']['symmetric_sortby'] = $field;
1713                                 // Hide fields, that are set automatically:
1714                         } else {
1715                                 $searchArray['%OR']['config'][0]['%AND']['%OR']['foreign_field'] = $field;
1716                                 $searchArray['%OR']['config'][0]['%AND']['%OR']['foreign_sortby'] = $field;
1717                         }
1718
1719                         $skipThisField = $this->compareStructureConfiguration($searchArray, true);
1720                 }
1721
1722                 return $skipThisField;
1723         }
1724
1725
1726         /**
1727          * Creates recursively a JSON literal from a mulidimensional associative array.
1728          * Uses Services_JSON (http://mike.teczno.com/JSON/doc/)
1729          *
1730          * @param       array           $jsonArray: The array (or part of) to be transformed to JSON
1731          * @return      string          If $level>0: part of JSON literal; if $level==0: whole JSON literal wrapped with <script> tags
1732          * @deprecated                  Since TYPO3 4.2: Moved to t3lib_div::array2json
1733          */
1734         function getJSON($jsonArray) {
1735                 return t3lib_div::array2json($jsonArray);
1736         }
1737
1738
1739         /**
1740          * Checks if a uid of a child table is in the inline view settings.
1741          *
1742          * @param       string          $table: Name of the child table
1743          * @param       integer         $uid: uid of the the child record
1744          * @return      boolean         true=expand, false=collapse
1745          */
1746         function getExpandedCollapsedState($table, $uid) {
1747                 if (is_array($this->inlineView) && is_array($this->inlineView[$table])) {
1748                         if (in_array($uid, $this->inlineView[$table]) !== false) return true;
1749                 }
1750                 return false;
1751         }
1752
1753
1754         /**
1755          * Update expanded/collapsed states on new inline records if any.
1756          *
1757          * @param       array           $uc: The uc array to be processed and saved (by reference)
1758          * @param       object          $tce: Instance of TCEmain that saved data before (by reference)
1759          * @return      void
1760          */
1761         function updateInlineView(&$uc, &$tce) {
1762                 if (is_array($uc) && $uc['inlineView']) {
1763                         $inlineView = unserialize($GLOBALS['BE_USER']->uc['inlineView']);
1764
1765                         foreach ($uc['inlineView'] as $topTable => $topRecords) {
1766                                 foreach ($topRecords as $topUid => $childElements) {
1767                                         foreach ($childElements as $childTable => $childRecords) {
1768                                                 $uids = array_keys($tce->substNEWwithIDs_table, $childTable);
1769                                                 if (count($uids)) {
1770                                                         foreach ($childRecords as $childUid => $state) {
1771                                                                 if ($state && in_array($childUid, $uids)) {
1772                                                                         $newChildUid = $tce->substNEWwithIDs[$childUid];
1773                                                                         $inlineView[$topTable][$topUid][$childTable][$newChildUid] = 1;
1774                                                                 }
1775                                                         }
1776                                                 }
1777                                         }
1778                                 }
1779                         }
1780
1781                         $GLOBALS['BE_USER']->uc['inlineView'] = serialize($inlineView);
1782                         $GLOBALS['BE_USER']->writeUC();
1783                 }
1784         }
1785
1786
1787         /**
1788          * Returns the the margin in pixels, that is used for each new inline level.
1789          *
1790          * @return      integer         A pixel value for the margin of each new inline level.
1791          */
1792         function getLevelMargin() {
1793                 $margin = ($this->inlineStyles['margin-right']+1)*2;
1794                 return $margin;
1795         }
1796 }
1797
1798
1799 if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_tceforms_inline.php'])   {
1800         include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_tceforms_inline.php']);
1801 }
1802 ?>