typo3/sysext/cms/tslib/class.tslib_content.php

   1 <?php
   2 /***************************************************************
   3 *  Copyright notice
   4 *
   5 *  (c) 1999-2008 Kasper Skaarhoj (kasperYYYY@typo3.com)
   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  * Contains classes for Content Rendering based on TypoScript Template configuration
  29  *
  30  * $Id$
  31  * Revised for TYPO3 3.6 June/2003 by Kasper Skaarhoj
  32  * XHTML compliant
  33  *
  34  * class tslib_cObj                     :               All main TypoScript features, rendering of content objects (cObjects). This class is the backbone of TypoScript Template rendering.
  35  * class tslib_controlTable             :               Makes a table CTABLE (TS cObject)
  36  * class tslib_tableOffset              :               Makes a table-offset (TS)
  37  * class tslib_frameset                 :               Generates framesets (TS)
  38  *
  39  * @author      Kasper Skaarhoj <kasperYYYY@typo3.com>
  40  */
  41 /**
  42  * [CLASS/FUNCTION INDEX of SCRIPT]
  43  *
  44  *
  45  *
  46  *  256: class tslib_cObj
  47  *  353:     function start($data,$table='')
  48  *  387:     function setParent($data,$currentRecord)
  49  *
  50  *              SECTION: CONTENT_OBJ:
  51  *  412:     function getCurrentVal()
  52  *  423:     function setCurrentVal($value)
  53  *  436:     function cObjGet($setup,$addKey='')
  54  *  460:     function cObjGetSingle($name,$conf,$TSkey='__')
  55  *
  56  *              SECTION: Functions rendering content objects (cObjects)
  57  *  629:     function HTML($conf)
  58  *  640:     function TEXT($conf)
  59  *  651:     function CLEARGIF($conf)
  60  *  670:     function COBJ_ARRAY($conf,$ext='')
  61  *  706:     function USER($conf,$ext='')
  62  *  733:     function FILE($conf)
  63  *  749:     function IMAGE($conf)
  64  *  768:     function IMG_RESOURCE($conf)
  65  *  780:     function IMGTEXT($conf)
  66  * 1203:     function CONTENT($conf)
  67  * 1290:     function RECORDS($conf)
  68  * 1370:     function HMENU($conf)
  69  * 1402:     function CTABLE ($conf)
  70  * 1440:     function OTABLE ($conf)
  71  * 1455:     function COLUMNS ($conf)
  72  * 1534:     function HRULER ($conf)
  73  * 1559:     function CASEFUNC ($conf)
  74  * 1584:     function LOAD_REGISTER($conf,$name)
  75  * 1624:     function FORM($conf,$formData='')
  76  * 2145:     function SEARCHRESULT($conf)
  77  * 2311:     function PHP_SCRIPT($conf,$ext='')
  78  * 2354:     function TEMPLATE($conf)
  79  * 2505:     function MULTIMEDIA($conf)
  80  *
  81  *              SECTION: Various helper functions for content objects:
  82  * 2592:     function getSlidePids($pidList, $pidConf)
  83  * 2623:     function getFieldDefaultValue($noValueInsert, $fieldName, $defaultVal)
  84  * 2641:     function cImage($file,$conf)
  85  * 2669:     function getBorderAttr($borderAttr)
  86  * 2685:     function imageLinkWrap($string,$imageFile,$conf)
  87  * 2765:     function fileResource($fName, $addParams='alt="" title=""')
  88  * 2788:     function lastChanged($tstamp)
  89  * 2805:     function linkWrap($content,$wrap)
  90  * 2824:     function getAltParam($conf, $longDesc=true)
  91  * 2859:     function cleanFormName($name)
  92  * 2875:     function getATagParams($conf, $addGlobal=1)
  93  *
  94  *              SECTION: HTML template processing functions
  95  * 2922:     function getSubpart($content, $marker)
  96  * 2938:     function substituteSubpart($content,$marker,$subpartContent,$recursive=1)
  97  * 2951:     function substituteMarker($content,$marker,$markContent)
  98  * 2971:     function substituteMarkerArrayCached($content,$markContentArray=array(),$subpartContentArray=array(),$wrappedSubpartContentArray=array())
  99  * 3069:     function substituteMarkerArray($content,$markContentArray,$wrap='',$uppercase=0)
 100  * 3081:     function substituteMarkerInObject(&$tree, $markContentArray)
 101  * 3104:     function fillInMarkerArray($markContentArray, $row, $fieldList='', $nl2br=TRUE, $prefix='FIELD_', $HSC=FALSE)
 102  *
 103  *              SECTION: "stdWrap" + sub functions
 104  * 3167:     function stdWrap($content,$conf)
 105  * 3364:     function numRows($conf)
 106  * 3388:     function listNum($content,$listNum,$char)
 107  * 3408:     function checkIf($conf)
 108  * 3471:     function filelist($data)
 109  * 3553:     function clean_directory($theDir)
 110  * 3571:     function HTMLparser_TSbridge($theValue, $conf)
 111  * 3585:     function dataWrap($content,$wrap)
 112  * 3598:     function insertData($str)
 113  * 3628:     function prefixComment($str,$conf,$content)
 114  * 3652:     function substring($content,$options)
 115  * 3670:     function crop($content,$options)
 116  * 3702:     function removeBadHTML($text, $conf)
 117  * 3746:     function textStyle($theValue, $conf)
 118  * 3813:     function tableStyle($theValue, $conf)
 119  * 3854:     function addParams($content,$conf)
 120  * 3895:     function filelink($theValue, $conf)
 121  * 3966:     function locDataJU($jumpUrl,$conf)
 122  * 3997:     function calc($val)
 123  * 4026:     function calcIntExplode($delim, $string)
 124  * 4046:     function splitObj($value, $conf)
 125  * 4108:     function parseFunc($theValue, $conf, $ref='')
 126  * 4218:     function _parseFunc ($theValue, $conf)
 127  * 4424:     function encaps_lineSplit($theValue, $conf)
 128  * 4507:     function http_makelinks($data,$conf)
 129  * 4574:     function mailto_makelinks($data,$conf)
 130  * 4617:     function getImgResource($file,$fileArray)
 131  *
 132  *              SECTION: Data retrieval etc.
 133  * 4810:     function getFieldVal($field)
 134  * 4830:     function getData($string,$fieldArray)
 135  * 4975:     function rootLineValue($key,$field,$slideBack=0,$altRootLine='')
 136  * 4997:     function getGlobal($var, $source=NULL)
 137  * 5033:     function getKey($key,$arr)
 138  * 5056:     function TCAlookup($inputValue,$conf)
 139  *
 140  *              SECTION: Link functions (typolink)
 141  * 5116:     function typoLink($linktxt, $conf)
 142  * 5481:     function typoLink_URL($conf)
 143  * 5499:     function getTypoLink($label,$params,$urlParameters=array(),$target='')
 144  * 5526:     function getTypoLink_URL($params,$urlParameters=array(),$target='')
 145  * 5538:     function typolinkWrap($conf)
 146  * 5551:     function currentPageUrl($urlParameters=array(),$id=0)
 147  * 5564:     function getClosestMPvalueForPage($pageId, $raw=FALSE)
 148  * 5619:     function getMailTo($mailAddress,$linktxt,$initP='?')
 149  * 5658:     function getQueryArguments($conf,$overruleQueryArgs=array(),$forceArgs=FALSE)
 150  *
 151  *              SECTION: Miscellaneous functions, stand alone
 152  * 5754:     function wrap($content,$wrap,$char='|')
 153  * 5770:     function noTrimWrap($content,$wrap)
 154  * 5784:     function wrapSpace($content, $wrap)
 155  * 5810:     function callUserFunction($funcName,$conf,$content)
 156  * 5851:     function processParams($params)
 157  * 5869:     function keywords($content)
 158  * 5886:     function caseshift($theValue, $case)
 159  * 5911:     function HTMLcaseshift($theValue, $case)
 160  * 5940:     function bytes($sizeInBytes,$labels)
 161  * 5951:     function calcAge($seconds,$labels)
 162  * 5983:     function sendNotifyEmail($msg, $recipients, $cc, $email_from, $email_fromName='', $replyTo='')
 163  * 6010:     function URLqMark($url,$params)
 164  * 6026:     function checkEmail($email)
 165  * 6038:     function clearTSProperties($TSArr,$propList)
 166  * 6057:     function mergeTSRef($confArr,$prop)
 167  * 6080:     function joinTSarrays($conf,$old_conf)
 168  * 6103:     function gifBuilderTextBox($gifbuilderConf, $conf, $text)
 169  * 6159:     function linebreaks($string,$chars,$maxLines=0)
 170  * 6190:     function getUpdateJS($dataArray, $formName, $arrPrefix, $fieldList)
 171  *
 172  *              SECTION: Database functions, making of queries
 173  * 6260:     function DBgetDelete($table, $uid, $doExec=FALSE)
 174  * 6292:     function DBgetUpdate($table, $uid, $dataArr, $fieldList, $doExec=FALSE)
 175  * 6334:     function DBgetInsert($table, $pid, $dataArr, $fieldList, $doExec=FALSE)
 176  * 6371:     function DBmayFEUserEdit($table,$row, $feUserRow, $allowedGroups='',$feEditSelf=0)
 177  * 6411:     function DBmayFEUserEditSelect($table,$feUserRow,$allowedGroups='',$feEditSelf=0)
 178  * 6451:     function enableFields($table,$show_hidden=0)
 179  * 6475:     function getTreeList($id,$depth,$begin=0,$dontCheckEnableFields=FALSE,$addSelectFields='',$moreWhereClauses='', $prevId_array=array(), $recursionLevel=0)
 180  * 6583:     function whereSelectFromList($field,$value)
 181  * 6601:     function exec_mm_query($select,$local_table,$mm_table,$foreign_table,$whereClause='',$groupBy='',$orderBy='',$limit='')
 182  * 6628:     function exec_mm_query_uidList($select,$local_table_uidlist,$mm_table,$foreign_table='',$whereClause='',$groupBy='',$orderBy='',$limit='')
 183  * 6649:     function searchWhere($sw,$searchFieldList,$searchTable='')
 184  * 6685:     function exec_getQuery($table, $conf)
 185  * 6703:     function getQuery($table, $conf, $returnQueryArray=FALSE)
 186  * 6783:     function getWhere($table,$conf, $returnQueryArray=FALSE)
 187  * 6878:     function checkPidArray($listArr)
 188  * 6902:     function checkPid($uid)
 189  *
 190  *              SECTION: Frontend editing functions
 191  * 6959:     function editPanel($content, $conf, $currentRecord='', $dataArr=array())
 192  * 7146:     function editIcons($content,$params, $conf=array(), $currentRecord='', $dataArr=array(),$addUrlParamStr='')
 193  * 7228:     function editPanelLinkWrap($string,$formName,$cmd,$currentRecord='',$confirm='',$nPid='')
 194  * 7270:     function editPanelLinkWrap_doWrap($string,$url,$currentRecord)
 195  * 7298:     function editPanelPreviewBorder($table,$row,$content,$thick,$conf=array())
 196  * 7320:     function isDisabled($table,$row)
 197  *
 198  *
 199  * 7351: class tslib_frameset
 200  * 7361:     function make($setup)
 201  * 7398:     function frameParams($setup, $typeNum)
 202  * 7426:     function framesetParams($setup)
 203  *
 204  *
 205  * 7459: class tslib_tableOffset
 206  * 7471:     function start($content,$offset)
 207  *
 208  *
 209  * 7549: class tslib_controlTable
 210  * 7584:     function start($offset,$cMargins)
 211  *
 212  * TOTAL FUNCTIONS: 135
 213  * (This index is automatically created/updated by the extension "extdeveval")
 214  *
 215  */
 216
 217
 218   // Includes this classes since it is used for parsing HTML
 219 require_once(PATH_t3lib."class.t3lib_parsehtml.php");
 220
 221         // Object TypoScript library included:
 222 if(t3lib_extMgm::isLoaded('obts')) {
 223         require_once(t3lib_extMgm::extPath('obts').'_tsobject/_tso.php');
 224 }
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242 /**
 243  * This class contains all main TypoScript features.
 244  * This includes the rendering of TypoScript content objects (cObjects).
 245  * Is the backbone of TypoScript Template rendering.
 246  *
 247  * There are lots of functions you can use from your include-scripts.
 248  * The class "tslib_cObj" is normally instantiated and referred to as "cObj".
 249  * When you call your own PHP-code typically through a USER or USER_INT cObject then it is this class that instantiates the object and calls the main method. Before it does so it will set (if you are using classes) a reference to itself in the internal variable "cObj" of the object. Thus you can access all functions and data from this class by $this->cObj->... from within you classes written to be USER or USER_INT content objects.
 250  *
 251  * @author      Kasper Skaarhoj <kasperYYYY@typo3.com>
 252  * @package TYPO3
 253  * @subpackage tslib
 254  * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&cHash=4ad9d7acb4
 255  */
 256 class tslib_cObj {
 257         var $align = Array ('center', 'right', 'left');
 258
 259         /**
 260          * Holds ImageMagick parameters and extensions used for compression
 261          *
 262          * @see IMGTEXT()
 263          *
 264          * 0= Default
 265          * 1= Dont change! (removes all parameters for the image_object!!)
 266          * 1x = GIFs
 267          * 2x = JPGs
 268          */
 269         var $image_compression = Array(
 270                 10 => Array('params'=>'', 'ext'=>'gif'),
 271                 11 => Array('params'=>'-colors 128', 'ext'=>'gif'),
 272                 12 => Array('params'=>'-colors 64', 'ext'=>'gif'),
 273                 13 => Array('params'=>'-colors 32', 'ext'=>'gif'),
 274                 14 => Array('params'=>'-colors 16', 'ext'=>'gif'),
 275                 15 => Array('params'=>'-colors 8', 'ext'=>'gif'),
 276
 277                 30 => Array('params'=>'-colors 256', 'ext'=>'png'),
 278                 31 => Array('params'=>'-colors 128', 'ext'=>'png'),
 279                 32 => Array('params'=>'-colors 64', 'ext'=>'png'),
 280                 33 => Array('params'=>'-colors 32', 'ext'=>'png'),
 281                 34 => Array('params'=>'-colors 16', 'ext'=>'png'),
 282                 35 => Array('params'=>'-colors 8', 'ext'=>'png'),
 283                 39 => Array('params'=>'', 'ext'=>'png'),
 284
 285                 20 => Array('params'=>'-quality 100', 'ext'=>'jpg'),
 286                 21 => Array('params'=>'-quality 90', 'ext'=>'jpg'),
 287                 22 => Array('params'=>'-quality 80', 'ext'=>'jpg'),
 288                 23 => Array('params'=>'-quality 70', 'ext'=>'jpg'),
 289                 24 => Array('params'=>'-quality 60', 'ext'=>'jpg'),
 290                 25 => Array('params'=>'-quality 50', 'ext'=>'jpg'),
 291                 26 => Array('params'=>'-quality 40', 'ext'=>'jpg'),
 292                 27 => Array('params'=>'-quality 30', 'ext'=>'jpg'),
 293                 28 => Array('params'=>'-quality 20', 'ext'=>'jpg')
 294         );
 295
 296         /**
 297          * ImageMagick parameters for image effects
 298          *
 299          * @see IMGTEXT()
 300          */
 301         var $image_effects = Array(
 302                 1 => '-rotate 90',
 303                 2 => '-rotate 270',
 304                 3 => '-rotate 180',
 305                 10 => '-colorspace GRAY',
 306                 11 => '-sharpen 70',
 307                 20 => '-normalize',
 308                 23 => '-contrast',
 309                 25 => '-gamma 1.3',
 310                 26 => '-gamma 0.8'
 311         );
 312
 313         /**
 314          * Loaded with the current data-record.
 315          *
 316          * If the instance of this class is used to render records from the database those records are found in this array.
 317          * The function stdWrap has TypoScript properties that fetch field-data from this array.
 318          * @see init()
 319          */
 320         var $data = Array();
 321         var $oldData = Array();                         // Used for backup...
 322         var $alternativeData ='';                       // If this is set with an array before stdWrap, it's used instead of $this->data in the data-property in stdWrap
 323         var $parameters = Array();                      // Used by the parseFunc function and is loaded with tag-parameters when parsing tags.
 324         var $currentValKey = 'currentValue_kidjls9dksoje';
 325         var $currentRecord = '';                        // This is set to the [table]:[uid] of the record delivered in the $data-array, if the cObjects CONTENT or RECORD is in operation. Note that $GLOBALS['TSFE']->currentRecord is set to an equal value but always indicating the latest record rendered.
 326         var $currentRecordTotal = 0;            // Set in cObj->RECORDS and cObj->CONTENT to the current number of records selected in a query.
 327         var $currentRecordNumber = 0;           // Incremented in cObj->RECORDS and cObj->CONTENT before each record rendering.
 328         var $parentRecordNumber = 0;            // Incremented in parent cObj->RECORDS and cObj->CONTENT before each record rendering.
 329         var $parentRecord = array();            // If the tslib_cObj was started from CONTENT, RECORD or SEARCHRESULT cObject's this array has two keys, 'data' and 'currentRecord' which indicates the record and data for the parent cObj.
 330         var $regObj;            // This may be set as a reference to the calling object of eg. cObjGetSingle. Anyway, just use it as you like. It's used in productsLib.inc for example.
 331
 332         // internal
 333         var $INT_include=0;             // Is set to 1 if the instance of this cObj is executed from a PHP_SCRIPT_INT -include script (see pagegen, bottom of document)
 334         var $checkPid_cache = Array();          // This is used by checkPid, that checks if pages are accessible. The $checkPid_cache['page_uid'] is set true or false upon this check featuring a caching function for the next request.
 335         var $checkPid_badDoktypeList = '255';
 336         var $lastTypoLinkUrl='';        // This will be set by typoLink() to the url of the most recent link created.
 337         var $lastTypoLinkTarget='';     // DO. link target.
 338         var $lastTypoLinkLD = array();
 339         var $substMarkerCache=array();  // Caching substituteMarkerArrayCached function
 340         var $recordRegister=array();    // Array that registers rendered content elements (or any table) to make sure they are not rendered recursively!
 341         var $cObjHookObjectsArr = array();              // Containig hooks for userdefined cObjects
 342         protected $stdWrapHookObjects = array();                // Containig hook objects for stdWrap
 343
 344         /**
 345          * Set to true by doConvertToUserIntObject() if USER object wants to become USER_INT
 346          */
 347         protected $doConvertToUserIntObject = false;
 348
 349         /**
 350          * Indicates current object type. Can hold one of OBJECTTYPE_ constants or false.
 351          * The value is set and reset inside USER() function. Any time outside of
 352          * USER() it is false.
 353          */
 354         protected $userObjectType = false;
 355
 356         /**
 357          * Indicates that object type is USER.
 358          *
 359          * @see tslib_cObjh::$userObjectType
 360          */
 361         const OBJECTTYPE_USER_INT = 1;
 362
 363         /**
 364          * Indicates that object type is USER.
 365          *
 366          * @see tslib_cObjh::$userObjectType
 367          */
 368         const OBJECTTYPE_USER = 2;
 369
 370         /**
 371          * Class constructor.
 372          * Well, it has to be called manually since it is not a real constructor function.
 373          * So after making an instance of the class, call this function and pass to it a database record and the tablename from where the record is from. That will then become the "current" record loaded into memory and accessed by the .fields property found in eg. stdWrap.
 374          *
 375          * @param       array           $data   the record data that is rendered.
 376          * @param       string          $table  the table that the data record is from.
 377          * @return      void
 378          */
 379         function start($data,$table='') {
 380                 global $TYPO3_CONF_VARS;
 381                 $this->data = $data;
 382                 $this->currentRecord = $table ? $table.':'.$this->data['uid'] : '';
 383                 $this->parameters = Array();
 384                 if (is_array ($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClass'])) {
 385                         foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClass'] as $classArr) {
 386                                 $this->cObjHookObjectsArr[$classArr[0]] = &t3lib_div::getUserObj($classArr[1]);
 387                         }
 388                 }
 389
 390                 if(is_array($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap'])) {
 391                         foreach($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap'] as $classData) {
 392                                 $hookObject = &t3lib_div::getUserObj($classData);
 393
 394                                 if(!($hookObject instanceof tslib_content_stdWrapHook)) {
 395                                         throw new UnexpectedValueException('$hookObject must implement interface tslib_content_stdWrapHook', 1195043965);
 396                                 }
 397
 398                                 $this->stdWrapHookObjects[] = $hookObject;
 399                         }
 400                 }
 401
 402         }
 403
 404         /**
 405          * Sets the internal variable parentRecord with information about current record.
 406          * If the tslib_cObj was started from CONTENT, RECORD or SEARCHRESULT cObject's this array has two keys, 'data' and 'currentRecord' which indicates the record and data for the parent cObj.
 407          *
 408          * @param       array           $data: The record array
 409          * @param       string          $currentRecord: This is set to the [table]:[uid] of the record delivered in the $data-array, if the cObjects CONTENT or RECORD is in operation. Note that $GLOBALS['TSFE']->currentRecord is set to an equal value but always indicating the latest record rendered.
 410          * @return      void
 411          * @access private
 412          */
 413         function setParent($data,$currentRecord)        {
 414                 $this->parentRecord=array('data'=>$data, 'currentRecord'=>$currentRecord);
 415         }
 416
 417
 418
 419
 420
 421
 422
 423
 424         /***********************************************
 425          *
 426          * CONTENT_OBJ:
 427          *
 428          ***********************************************/
 429
 430         /**
 431          * Returns the "current" value.
 432          * The "current" value is just an internal variable that can be used by functions to pass a single value on to another function later in the TypoScript processing.
 433          * It's like "load accumulator" in the good old C64 days... basically a "register" you can use as you like.
 434          * The TSref will tell if functions are setting this value before calling some other object so that you know if it holds any special information.
 435          *
 436          * @return      mixed           The "current" value
 437          */
 438         function getCurrentVal()        {
 439                 return $this->data[$this->currentValKey];
 440         }
 441
 442         /**
 443          * Sets the "current" value.
 444          *
 445          * @param       mixed           The variable that you want to set as "current"
 446          * @return      void
 447          * @see getCurrentVal()
 448          */
 449         function setCurrentVal($value)  {
 450                 $this->data[$this->currentValKey] = $value;
 451         }
 452
 453         /**
 454          * Rendering of a "numerical array" of cObjects from TypoScript
 455          * Will call ->cObjGetSingle() for each cObject found and accumulate the output.
 456          *
 457          * @param       array           $setup: Array with cObjects as values.
 458          * @param       string          $addKey: A prefix for the debugging information
 459          * @return      string          Rendered output from the cObjects in the array.
 460          * @see cObjGetSingle()
 461          */
 462         function cObjGet($setup,$addKey='')     {
 463                 if (is_array($setup))   {
 464                         $sKeyArray=t3lib_TStemplate::sortedKeyList($setup);
 465                         $content ='';
 466                         foreach($sKeyArray as $theKey)  {
 467                                 $theValue=$setup[$theKey];
 468                                 if (intval($theKey) && !strstr($theKey,'.'))    {
 469                                         $conf=$setup[$theKey.'.'];
 470                                         $content.=$this->cObjGetSingle($theValue,$conf,$addKey.$theKey);        // Get the contentObject
 471                                 }
 472                         }
 473                         return $content;
 474                 }
 475         }
 476
 477         /**
 478          * Renders a content object
 479          *
 480          * @param       string          The content object name, eg. "TEXT" or "USER" or "IMAGE"
 481          * @param       array           The array with TypoScript properties for the content object
 482          * @param       string          A string label used for the internal debugging tracking.
 483          * @return      string          cObject output
 484          * @example http://typo3.org/doc.0.html?&encryptionKey=&tx_extrepmgm_pi1[extUid]=267&tx_extrepmgm_pi1[tocEl]=153&cHash=7e74f4d331
 485          */
 486         function cObjGetSingle($name,$conf,$TSkey='__') {
 487                 global $TYPO3_CONF_VARS;
 488
 489                 $content='';
 490                         // Checking that the function is not called eternally. This is done by interrupting at a depth of 100
 491                 $GLOBALS['TSFE']->cObjectDepthCounter--;
 492                 if ($GLOBALS['TSFE']->cObjectDepthCounter>0)    {
 493                         $name = trim($name);
 494                         if ($GLOBALS['TT']->LR) $GLOBALS['TT']->push($TSkey, $name);
 495
 496                                 // Checking if the COBJ is a reference to another object. (eg. name of 'blabla.blabla = < styles.something')
 497                         if (substr($name,0,1)=='<')     {
 498                                 $key = trim(substr($name,1));
 499                                 $cF = t3lib_div::makeInstance('t3lib_TSparser');
 500                                         // $name and $conf is loaded with the referenced values.
 501                                 $old_conf=$conf;
 502                                 list($name, $conf) = $cF->getVal($key,$GLOBALS['TSFE']->tmpl->setup);
 503                                 if (is_array($old_conf) && count($old_conf))    {
 504                                         $conf = $this->joinTSarrays($conf,$old_conf);
 505                                 }
 506                                         // Getting the cObject
 507                                 $GLOBALS['TT']->incStackPointer();
 508                                         $content.=$this->cObjGetSingle($name,$conf,$key);
 509                                 $GLOBALS['TT']->decStackPointer();
 510                         } else {
 511
 512                                 $hooked = false;
 513                                         // Application defined cObjects
 514                                 foreach ($this->cObjHookObjectsArr as $cObjName => $hookObj)    {
 515                                         if (($name===$cObjName) && method_exists($hookObj, 'cObjGetSingleExt')) {
 516                                                 $content.= $hookObj->cObjGetSingleExt($name, $conf, $TSkey, $this);
 517                                                 $hooked = true;
 518                                         }
 519                                 }
 520                                 if (!$hooked && isset($GLOBALS['OBTS']['tso_list'][$name]) && t3lib_extMgm::isLoaded('obts')) {
 521                                         $content.= obts_dtutil::renderDatatypeContent($name, $GLOBALS['OBTS']['tso_list'][$name], $conf, $this);
 522                                 } elseif (!$hooked) {
 523                                                 // Traditional Content Object branching:
 524                                         switch($name)   {
 525                                                 case 'COBJ_ARRAY':
 526                                                 case 'COA':
 527                                                         $content.=$this->COBJ_ARRAY($conf);
 528                                                 break;
 529                                                 case 'COA_INT':
 530                                                         $content.=$this->COBJ_ARRAY($conf,'INT');
 531                                                 break;
 532                                                 case 'HTML':
 533                                                         $content.=$this->HTML($conf);
 534                                                 break;
 535                                                 case 'TEXT':
 536                                                         $content.=$this->TEXT($conf);
 537                                                 break;
 538                                                 case 'CLEARGIF':
 539                                                         $content.=$this->CLEARGIF($conf);
 540                                                 break;
 541                                                 case 'FILE':
 542                                                         $content.=$this->FILE($conf);
 543                                                 break;
 544                                                 case 'IMAGE':
 545                                                         $content.=$this->IMAGE($conf);
 546                                                 break;
 547                                                 case 'IMG_RESOURCE':
 548                                                         $content.=$this->IMG_RESOURCE($conf);
 549                                                 break;
 550                                                 case 'IMGTEXT':
 551                                                         $content.=$this->IMGTEXT($conf);
 552                                                 break;
 553                                                 case 'CONTENT':
 554                                                         $content.=$this->CONTENT($conf);
 555                                                 break;
 556                                                 case 'RECORDS':
 557                                                         $content.=$this->RECORDS($conf);
 558                                                 break;
 559                                                 case 'HMENU':
 560                                                         $content.=$this->HMENU($conf);
 561                                                 break;
 562                                                 case 'CTABLE':
 563                                                         $content.=$this->CTABLE($conf);
 564                                                 break;
 565                                                 case 'OTABLE':
 566                                                         $content.=$this->OTABLE($conf);
 567                                                 break;
 568                                                 case 'COLUMNS':
 569                                                         $content.=$this->COLUMNS($conf);
 570                                                 break;
 571                                                 case 'HRULER':
 572                                                         $content.=$this->HRULER($conf);
 573                                                 break;
 574                                                 case 'CASE':
 575                                                         $content.=$this->CASEFUNC($conf);
 576                                                 break;
 577                                                 case 'LOAD_REGISTER':
 578                                                 case 'RESTORE_REGISTER':
 579                                                         $this->LOAD_REGISTER($conf,$name);
 580                                                 break;
 581                                                 case 'FORM':
 582                                                         $content.=$this->FORM($conf);
 583                                                 break;
 584                                                 case 'SEARCHRESULT':
 585                                                         $content.=$this->SEARCHRESULT($conf);
 586                                                 break;
 587                                                 case 'PHP_SCRIPT':
 588                                                         $content.=$this->PHP_SCRIPT($conf);
 589                                                 break;
 590                                                 case 'PHP_SCRIPT_EXT':
 591                                                         $content.=$this->PHP_SCRIPT($conf,'EXT');
 592                                                 break;
 593                                                 case 'PHP_SCRIPT_INT':
 594                                                         $content.=$this->PHP_SCRIPT($conf,'INT');
 595                                                 break;
 596                                                 case 'USER':
 597                                                         $content.=$this->USER($conf);
 598                                                 break;
 599                                                 case 'USER_INT':
 600                                                         $content.=$this->USER($conf,'INT');
 601                                                 break;
 602                                                 case 'TEMPLATE':
 603                                                         $content.=$this->TEMPLATE($conf);
 604                                                 break;
 605                                                 case 'EDITPANEL':
 606                                                         if ($GLOBALS['TSFE']->beUserLogin)      {$content.=$this->editPanel($content, $conf);}
 607                                                 break;
 608                                                 case 'MULTIMEDIA':
 609                                                         $content.=$this->MULTIMEDIA($conf);
 610                                                 break;
 611                                                 default:
 612                                                                 // call hook functions for extra processing
 613                                                         if($name && is_array($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClassDefault']))    {
 614                                                                 foreach($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClassDefault'] as $classData)    {
 615                                                                         $hookObject = &t3lib_div::getUserObj($classData);
 616
 617                                                                         if(!($hookObject instanceof tslib_content_cObjGetSingleHook)) {
 618                                                                                 throw new UnexpectedValueException('$hookObject must implement interface tslib_content_cObjGetSingleHook', 1195043731);
 619                                                                         }
 620                                                                         /* @var $hookObject tslib_content_cObjGetSingleHook */
 621                                                                         $content .= $hookObject->getSingleContentObject($name, (array) $conf, $TSkey, $this);
 622                                                                 }
 623                                                         }
 624                                                 break;
 625                                         }
 626                                 }
 627                         }
 628                         if ($GLOBALS['TT']->LR) $GLOBALS['TT']->pull($content);
 629                 }
 630                         // Increasing on exit...
 631                 $GLOBALS['TSFE']->cObjectDepthCounter++;
 632                 return $content;
 633         }
 634
 635
 636
 637
 638
 639
 640
 641         /********************************************
 642          *
 643          * Functions rendering content objects (cObjects)
 644          *
 645          ********************************************/
 646
 647         /**
 648          * Rendering the cObject, HTML
 649          *
 650          * @param       array           Array of TypoScript properties
 651          * @return      string          Output
 652          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=349&cHash=d3fd0c70b4
 653          */
 654         function HTML($conf)    {
 655                 return $this->stdWrap($conf['value'],$conf['value.']);
 656         }
 657
 658         /**
 659          * Rendering the cObject, TEXT
 660          *
 661          * @param       array           Array of TypoScript properties
 662          * @return      string          Output
 663          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=350&cHash=b49de28f83
 664          */
 665         function TEXT($conf)    {
 666                 return $this->stdWrap($conf['value'],$conf);
 667         }
 668
 669         /**
 670          * Rendering the cObject, CLEARGIF
 671          *
 672          * @param       array           Array of TypoScript properties
 673          * @return      string          Output
 674          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=355&cHash=70c0f19915
 675          */
 676         function CLEARGIF($conf)        {
 677                 $w = $this->stdWrap($conf['width'],$conf['width.']);
 678                 $h = $this->stdWrap($conf['height'],$conf['height.']);
 679                 $w = $w ? $w : 1;
 680                 $h = $h ? $h : 1;
 681                 $wrap = $conf['wrap'] ? $conf['wrap'] : '|<br />';
 682                 $theValue = $this->wrap('<img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$w.'" height="'.$h.'"'.$this->getBorderAttr(' border="0"').' alt="" title="" />', $wrap);
 683
 684                 return $this->stdWrap($theValue,$conf['stdWrap.']);
 685         }
 686
 687         /**
 688          * Rendering the cObject, COBJ_ARRAY / COA and COBJ_ARRAY_INT
 689          *
 690          * @param       array           Array of TypoScript properties
 691          * @param       string          If "INT" then the cObject is a "COBJ_ARRAY_INT" (non-cached), otherwise just "COBJ_ARRAY" (cached)
 692          * @return      string          Output
 693          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=351&cHash=a09db0329c
 694          */
 695         function COBJ_ARRAY($conf,$ext='')      {
 696
 697                 if (is_array($conf)) {
 698                         $content = '';
 699                         switch($ext) {
 700                                 case 'INT':
 701                                         $substKey = $ext . '_SCRIPT.' . $GLOBALS['TSFE']->uniqueHash();
 702                                         $content .= '<!--'.$substKey.'-->';
 703                                         $GLOBALS['TSFE']->config[$ext . 'incScript'][$substKey] = array (
 704                                                 'file' => $conf['includeLibs'],
 705                                                 'conf' => $conf,
 706                                                 'cObj' => serialize($this),
 707                                                 'type' => 'COA'
 708                                         );
 709                                 break;
 710                                 default:
 711                                         if ($this->checkIf($conf['if.'])) {
 712                                                 $this->includeLibs($conf);
 713                                                 $content = $this->cObjGet($conf);
 714                                                 if ($conf['wrap']) {
 715                                                         $content = $this->wrap($content, $conf['wrap']);
 716                                                 }
 717                                                 if ($conf['stdWrap.']) {
 718                                                         $content = $this->stdWrap($content, $conf['stdWrap.']);
 719                                                 }
 720                                         }
 721                                 break;
 722                         }
 723                         return $content;
 724                 } else {
 725                         $GLOBALS['TT']->setTSlogMessage('No elements in this content object array (COBJ_ARRAY, COA, COA_INT).', 2);
 726                 }
 727         }
 728
 729         /**
 730          * Rendering the cObject, USER and USER_INT
 731          *
 732          * @param       array           Array of TypoScript properties
 733          * @param       string          If "INT" then the cObject is a "USER_INT" (non-cached), otherwise just "USER" (cached)
 734          * @return      string          Output
 735          * @link        http://typo3.org/documentation/document-library/references/doc_core_tsref/4.1.0/view/8/22/
 736          */
 737         function USER($conf, $ext = '') {
 738                 $content = '';
 739                 switch ($ext) {
 740                         case 'INT':
 741                                 $this->userObjectType = self::OBJECTTYPE_USER_INT;
 742                                 $substKey = $ext . '_SCRIPT.' . $GLOBALS['TSFE']->uniqueHash();
 743                                 $content.='<!--' . $substKey . '-->';
 744                                 $GLOBALS['TSFE']->config[$ext . 'incScript'][$substKey] = array(
 745                                         'file' => $conf['includeLibs'],
 746                                         'conf' => $conf,
 747                                         'cObj' => serialize($this),
 748                                         'type' => 'FUNC'
 749                                 );
 750                                 break;
 751                         default:
 752                                 if ($this->userObjectType === false) {
 753                                         // Come here only if we are not called from $TSFE->INTincScript_process()!
 754                                         $this->userObjectType = self::OBJECTTYPE_USER;
 755                                 }
 756                                 $this->includeLibs($conf);
 757                                 $tempContent = $this->callUserFunction($conf['userFunc'], $conf, '');
 758                                 if ($this->doConvertToUserIntObject) {
 759                                         $this->doConvertToUserIntObject = false;
 760                                         $content = $this->USER($conf, 'INT');
 761                                 } else {
 762                                         $content .= $tempContent;
 763                                 }
 764                                 break;
 765                 }
 766                 $this->userObjectType = false;
 767                 return $content;
 768         }
 769
 770         /**
 771          * Retrieves a type of object called as USER or USER_INT. Object can detect their
 772          * type by using this call. It returns OBJECTTYPE_USER_INT or OBJECTTYPE_USER depending on the
 773          * current object execution. In all other cases it will return false to indicate
 774          * a call out of context.
 775          *
 776          * @return      mixed   One of OBJECTTYPE_ class constants or false
 777          */
 778         public function getUserObjectType() {
 779                 return $this->userObjectType;
 780         }
 781
 782         /**
 783          * Requests the current USER object to be converted to USER_INT.
 784          *
 785          * @return      void
 786          */
 787         public function convertToUserIntObject() {
 788                 if ($this->userObjectType !== self::OBJECTTYPE_USER) {
 789                         $GLOBALS['TT']->setTSlogMessage('tslib_cObj::convertToUserIntObject() ' .
 790                                 'is called in the wrong context or for the wrong object type', 2);
 791                 }
 792                 else {
 793                         $this->doConvertToUserIntObject = true;
 794                 }
 795         }
 796
 797         /**
 798          * Rendering the cObject, FILE
 799          *
 800          * @param       array           Array of TypoScript properties
 801          * @return      string          Output
 802          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=352&cHash=379c60f8bc
 803          */
 804         function FILE($conf)    {
 805                 $theValue = $this->fileResource($this->stdWrap($conf['file'],$conf['file.']), trim($this->getAltParam($conf, false)));
 806                 if ($conf['linkWrap'])  {
 807                         $theValue = $this->linkWrap($theValue,$conf['linkWrap']);
 808                 }
 809                 return $this->wrap($theValue,$conf['wrap']);
 810         }
 811
 812         /**
 813          * Rendering the cObject, IMAGE
 814          *
 815          * @param       array           Array of TypoScript properties
 816          * @return      string          Output
 817          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=353&cHash=440681ea56
 818          * @see cImage()
 819          */
 820         function IMAGE($conf)   {
 821                 $content='';
 822                 if ($this->checkIf($conf['if.']))       {
 823                         $theValue = $this->cImage($conf['file'],$conf);
 824                         if ($conf['stdWrap.'])  {
 825                                 $theValue = $this->stdWrap($theValue,$conf['stdWrap.']);
 826                         }
 827                         return $theValue;
 828                 }
 829         }
 830
 831         /**
 832          * Rendering the cObject, IMG_RESOURCE
 833          *
 834          * @param       array           Array of TypoScript properties
 835          * @return      string          Output
 836          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=354&cHash=46f9299706
 837          * @see getImgResource()
 838          */
 839         function IMG_RESOURCE($conf)    {
 840                 $GLOBALS['TSFE']->lastImgResourceInfo = $this->getImgResource($conf['file'],$conf['file.']);
 841                 return $this->stdWrap($GLOBALS['TSFE']->lastImgResourceInfo[3],$conf['stdWrap.']);
 842         }
 843
 844         /**
 845          * Rendering the cObject, IMGTEXT
 846          *
 847          * @param       array           Array of TypoScript properties
 848          * @return      string          Output
 849          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=363&cHash=cf2969bce1
 850          */
 851         function IMGTEXT($conf) {
 852                 $content='';
 853                 if (is_array($conf['text.']))   {
 854                         $content.= $this->stdWrap($this->cObjGet($conf['text.'],'text.'),$conf['text.']);       // this gets the surrounding content
 855                 }
 856                 $imgList=trim($this->stdWrap($conf['imgList'],$conf['imgList.']));      // gets images
 857                 if ($imgList)   {
 858                         $imgs = t3lib_div::trimExplode(',',$imgList);
 859                         $imgStart = intval($this->stdWrap($conf['imgStart'],$conf['imgStart.']));
 860
 861                         $imgCount= count($imgs)-$imgStart;
 862
 863                         $imgMax = intval($this->stdWrap($conf['imgMax'],$conf['imgMax.']));
 864                         if ($imgMax)    {
 865                                 $imgCount = t3lib_div::intInRange($imgCount,0,$imgMax); // reduces the number of images.
 866                         }
 867
 868                         $imgPath = $this->stdWrap($conf['imgPath'],$conf['imgPath.']);
 869
 870                                 // initialisation
 871                         $caption='';
 872                         $captionArray = array();
 873                         if (!$conf['captionSplit'] && !$conf['imageTextSplit'] && is_array($conf['caption.']))  {
 874                                 $caption = $this->stdWrap($this->cObjGet($conf['caption.'], 'caption.'),$conf['caption.']);     // global caption, no splitting
 875                         }
 876                         if ($conf['captionSplit'] && $conf['captionSplit.']['cObject']) {
 877                                 $legacyCaptionSplit = 1;
 878                                 $capSplit = $this->stdWrap($conf['captionSplit.']['token'], $conf['captionSplit.']['token.']);
 879                                 if (!$capSplit) {$capSplit=chr(10);}
 880                                 $captionArray = explode($capSplit, $this->cObjGetSingle($conf['captionSplit.']['cObject'], $conf['captionSplit.']['cObject.'], 'captionSplit.cObject'));
 881                                 while (list($ca_key, $ca_val) = each($captionArray))    {
 882                                         $captionArray[$ca_key] = $this->stdWrap(trim($captionArray[$ca_key]), $conf['captionSplit.']['stdWrap.']);
 883                                 }
 884                         }
 885
 886                         $tablecode='';
 887                         $position=$this->stdWrap($conf['textPos'],$conf['textPos.']);
 888
 889                         $tmppos = $position&7;
 890                         $contentPosition = $position&24;
 891                         $align = $this->align[$tmppos];
 892                         $cap = ($caption)?1:0;
 893                         $txtMarg = intval($this->stdWrap($conf['textMargin'],$conf['textMargin.']));
 894                         if (!$conf['textMargin_outOfText'] && $contentPosition<16)      {
 895                                 $txtMarg=0;
 896                         }
 897
 898                         $cols = intval($this->stdWrap($conf['cols'],$conf['cols.']));
 899                         $rows = intval($this->stdWrap($conf['rows'],$conf['rows.']));
 900                         $colspacing = intval($this->stdWrap($conf['colSpace'],$conf['colSpace.']));
 901                         $rowspacing = intval($this->stdWrap($conf['rowSpace'],$conf['rowSpace.']));
 902
 903                         $border = intval($this->stdWrap($conf['border'],$conf['border.'])) ? 1:0;
 904                         $borderColor = $this->stdWrap($conf['borderCol'],$conf['borderCol.']);
 905                         $borderThickness = intval($this->stdWrap($conf['borderThick'],$conf['borderThick.']));
 906
 907                         $borderColor=$borderColor?$borderColor:'black';
 908                         $borderThickness=$borderThickness?$borderThickness:1;
 909
 910                         $caption_align = $this->stdWrap($conf['captionAlign'],$conf['captionAlign.']);
 911                         if (!$caption_align) {
 912                                 $caption_align = $align;
 913                         }
 914                                 // generate cols
 915                         $colCount = ($cols > 1) ? $cols : 1;
 916                         if ($colCount > $imgCount)      {$colCount = $imgCount;}
 917                         $rowCount = ($colCount > 1) ? ceil($imgCount / $colCount) : $imgCount;
 918                                 // generate rows
 919                         if ($rows>1)  {
 920                                 $rowCount = $rows;
 921                                 if ($rowCount > $imgCount)      {$rowCount = $imgCount;}
 922                                 $colCount = ($rowCount>1) ? ceil($imgCount / $rowCount) : $imgCount;
 923                         }
 924
 925                                 // max Width
 926                         $colRelations = trim($this->stdWrap($conf['colRelations'],$conf['colRelations.']));
 927                         $maxW = intval($this->stdWrap($conf['maxW'],$conf['maxW.']));
 928
 929                         $maxWInText = intval($this->stdWrap($conf['maxWInText'],$conf['maxWInText.']));
 930                         if (!$maxWInText)       {       // If maxWInText is not set, it's calculated to the 50 % of the max...
 931                                 $maxWInText = round($maxW/2);
 932                         }
 933
 934                         if ($maxWInText && $contentPosition>=16)        {       // inText
 935                                 $maxW = $maxWInText;
 936                         }
 937
 938                         if ($maxW && $colCount > 0) {   // If there is a max width and if colCount is greater than  column
 939 /*                              debug($border*$borderThickness*2);
 940                                 debug($maxW);
 941                                 debug($colspacing);
 942                                 debug(($maxW-$colspacing*($colCount-1)-$colCount*$border*$borderThickness*2));
 943                                 */
 944                                 $maxW = ceil(($maxW-$colspacing*($colCount-1)-$colCount*$border*$borderThickness*2)/$colCount);
 945                         }
 946                                 // create the relation between rows
 947                         $colMaxW = Array();
 948                         if ($colRelations)      {
 949                                 $rel_parts = explode(':',$colRelations);
 950                                 $rel_total = 0;
 951                                 for ($a=0;$a<$colCount;$a++)    {
 952                                         $rel_parts[$a] = intval($rel_parts[$a]);
 953                                         $rel_total+= $rel_parts[$a];
 954                                 }
 955                                 if ($rel_total) {
 956                                         for ($a=0;$a<$colCount;$a++)    {
 957                                                 $colMaxW[$a] = round(($maxW*$colCount)/$rel_total*$rel_parts[$a]);
 958                                         }
 959                                         if (min($colMaxW)<=0 || max($rel_parts)/min($rel_parts)>10)     {               // The difference in size between the largest and smalles must be within a factor of ten.
 960                                                 $colMaxW = Array();
 961                                         }
 962                                 }
 963                         }
 964                         $image_compression = intval($this->stdWrap($conf['image_compression'],$conf['image_compression.']));
 965                         $image_effects = intval($this->stdWrap($conf['image_effects'],$conf['image_effects.']));
 966                         $image_frames = intval($this->stdWrap($conf['image_frames.']['key'],$conf['image_frames.']['key.']));
 967
 968                                 // fetches pictures
 969                         $splitArr=array();
 970                         $splitArr['imgObjNum']=$conf['imgObjNum'];
 971                         $splitArr = $GLOBALS['TSFE']->tmpl->splitConfArray($splitArr,$imgCount);
 972
 973                                 // EqualHeight
 974                         $equalHeight = intval($this->stdWrap($conf['equalH'],$conf['equalH.']));
 975                         if ($equalHeight)       {       // Initiate gifbuilder object in order to get dimensions AND calculate the imageWidth's
 976                                 $gifCreator = t3lib_div::makeInstance('tslib_gifbuilder');
 977                                 $gifCreator->init();
 978                                 $relations = Array();
 979                                 $relations_cols = Array();
 980                                 $totalMaxW = $maxW*$colCount;
 981                                 for($a=0;$a<$imgCount;$a++)     {
 982                                         $imgKey = $a+$imgStart;
 983                                         $imgInfo = $gifCreator->getImageDimensions($imgPath.$imgs[$imgKey]);
 984                                         $relations[$a] = $imgInfo[1] / $equalHeight;    // relationship between the original height and the wished height
 985                                         if ($relations[$a])     {       // if relations is zero, then the addition of this value is omitted as the image is not expected to display because of some error.
 986                                                 $relations_cols[floor($a/$colCount)] += $imgInfo[0]/$relations[$a];     // counts the total width of the row with the new height taken into consideration.
 987                                         }
 988                                 }
 989                         }
 990
 991                         $imageRowsFinalWidths = Array();        // contains the width of every image row
 992                         $imageRowsMaxHeights = Array();
 993                         $imgsTag=array();
 994                         $origImages=array();
 995                         for($a=0;$a<$imgCount;$a++)     {
 996                                 $GLOBALS['TSFE']->register['IMAGE_NUM'] = $a;
 997                                 $GLOBALS['TSFE']->register['IMAGE_NUM_CURRENT'] = $a;
 998
 999                                 $imgKey = $a+$imgStart;
1000                                 $totalImagePath = $imgPath.$imgs[$imgKey];
1001                                 $this->data[$this->currentValKey] = $totalImagePath;
1002                                 $imgObjNum = intval($splitArr[$a]['imgObjNum']);
1003                                 $imgConf = $conf[$imgObjNum.'.'];
1004
1005                                 if ($equalHeight)       {
1006                                         $scale = 1;
1007                                         if ($totalMaxW) {
1008                                                 $rowTotalMaxW = $relations_cols[floor($a/$colCount)];
1009                                                 if ($rowTotalMaxW > $totalMaxW) {
1010                                                         $scale = $rowTotalMaxW / $totalMaxW;
1011                                                 }
1012                                         }
1013                                                 // transfer info to the imageObject. Please note, that
1014                                         $imgConf['file.']['height'] = round($equalHeight/$scale);
1015
1016                                         unset($imgConf['file.']['width']);
1017                                         unset($imgConf['file.']['maxW']);
1018                                         unset($imgConf['file.']['maxH']);
1019                                         unset($imgConf['file.']['minW']);
1020                                         unset($imgConf['file.']['minH']);
1021                                         unset($imgConf['file.']['width.']);
1022                                         unset($imgConf['file.']['maxW.']);
1023                                         unset($imgConf['file.']['maxH.']);
1024                                         unset($imgConf['file.']['minW.']);
1025                                         unset($imgConf['file.']['minH.']);
1026                                         $maxW = 0;      // setting this to zero, so that it doesn't disturb
1027                                 }
1028
1029                                 if ($maxW) {
1030                                         if (count($colMaxW))    {
1031                                                 $imgConf['file.']['maxW'] = $colMaxW[($a%$colCount)];
1032                                         } else {
1033                                                 $imgConf['file.']['maxW'] = $maxW;
1034                                         }
1035                                 }
1036
1037                                         // Image Object supplied:
1038                                 if (is_array($imgConf)) {
1039                                         if ($this->image_effects[$image_effects])       {
1040                                                 $imgConf['file.']['params'].= ' '.$this->image_effects[$image_effects];
1041                                         }
1042                                         if ($image_frames)      {
1043                                                 if (is_array($conf['image_frames.'][$image_frames.'.']))        {
1044                                                         $imgConf['file.']['m.'] = $conf['image_frames.'][$image_frames.'.'];
1045                                                 }
1046                                         }
1047                                         if ($image_compression && $imgConf['file']!='GIFBUILDER')       {
1048                                                 if ($image_compression==1)      {
1049                                                         $tempImport = $imgConf['file.']['import'];
1050                                                         $tempImport_dot = $imgConf['file.']['import.'];
1051                                                         unset($imgConf['file.']);
1052                                                         $imgConf['file.']['import'] = $tempImport;
1053                                                         $imgConf['file.']['import.'] = $tempImport_dot;
1054                                                 } elseif (isset($this->image_compression[$image_compression])) {
1055                                                         $imgConf['file.']['params'].= ' '.$this->image_compression[$image_compression]['params'];
1056                                                         $imgConf['file.']['ext'] = $this->image_compression[$image_compression]['ext'];
1057                                                         unset($imgConf['file.']['ext.']);
1058                                                 }
1059                                         }
1060
1061                                                 // "alt", "title" and "longdesc" attributes:
1062                                         if (!strlen($imgConf['altText']) && !is_array($imgConf['altText.'])) {
1063                                                 $imgConf['altText'] = $conf['altText'];
1064                                                 $imgConf['altText.'] = $conf['altText.'];
1065                                         }
1066                                         if (!strlen($imgConf['titleText']) && !is_array($imgConf['titleText.'])) {
1067                                                 $imgConf['titleText'] = $conf['titleText'];
1068                                                 $imgConf['titleText.'] = $conf['titleText.'];
1069                                         }
1070                                         if (!strlen($imgConf['longdescURL']) && !is_array($imgConf['longdescURL.'])) {
1071                                                 $imgConf['longdescURL'] = $conf['longdescURL'];
1072                                                 $imgConf['longdescURL.'] = $conf['longdescURL.'];
1073                                         }
1074                                 } else {
1075                                         $imgConf = array(
1076                                                 'altText' => $conf['altText'],
1077                                                 'titleText' => $conf['titleText'],
1078                                                 'longdescURL' => $conf['longdescURL'],
1079                                                 'file' => $totalImagePath
1080                                         );
1081                                 }
1082
1083                                 $imgsTag[$imgKey] = $this->IMAGE($imgConf);
1084
1085                                         // Store the original filepath
1086                                 $origImages[$imgKey]=$GLOBALS['TSFE']->lastImageInfo;
1087
1088                                 $imageRowsFinalWidths[floor($a/$colCount)] += $GLOBALS['TSFE']->lastImageInfo[0];
1089                                 if ($GLOBALS['TSFE']->lastImageInfo[1]>$imageRowsMaxHeights[floor($a/$colCount)])       {
1090                                         $imageRowsMaxHeights[floor($a/$colCount)] = $GLOBALS['TSFE']->lastImageInfo[1];
1091                                 }
1092                         }
1093                                 // calculating the tableWidth:
1094                                 // TableWidth problems: It creates problems if the pictures are NOT as wide as the tableWidth.
1095                         $tableWidth = max($imageRowsFinalWidths)+ $colspacing*($colCount-1) + $colCount*$border*$borderThickness*2;
1096
1097                                 // make table for pictures
1098                         $index=$imgStart;
1099
1100                         $noRows = $this->stdWrap($conf['noRows'],$conf['noRows.']);
1101                         $noCols = $this->stdWrap($conf['noCols'],$conf['noCols.']);
1102                         if ($noRows) {$noCols=0;}       // noRows overrides noCols. They cannot exist at the same time.
1103                         if ($equalHeight) {
1104                                 $noCols=1;
1105                                 $noRows=0;
1106                         }
1107
1108                         $rowCount_temp=1;
1109                         $colCount_temp=$colCount;
1110                         if ($noRows)    {
1111                                 $rowCount_temp = $rowCount;
1112                                 $rowCount=1;
1113                         }
1114                         if ($noCols)    {
1115                                 $colCount=1;
1116                         }
1117                                 // col- and rowspans calculated
1118                         $colspan = (($colspacing) ? $colCount*2-1 : $colCount);
1119                         $rowspan = (($rowspacing) ? $rowCount*2-1 : $rowCount) + $cap;
1120
1121
1122                                 // Edit icons:
1123                         $editIconsHTML = $conf['editIcons']&&$GLOBALS['TSFE']->beUserLogin ? $this->editIcons('',$conf['editIcons'],$conf['editIcons.']) : '';
1124
1125                                 // strech out table:
1126                         $tablecode='';
1127                         $flag=0;
1128                         if ($conf['noStretchAndMarginCells']!=1)        {
1129                                 $tablecode.='<tr>';
1130                                 if ($txtMarg && $align=='right')        {       // If right aligned, the textborder is added on the right side
1131                                         $tablecode.='<td rowspan="'.($rowspan+1).'" valign="top"><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$txtMarg.'" height="1" alt="" title="" />'.($editIconsHTML?'<br />'.$editIconsHTML:'').'</td>';
1132                                         $editIconsHTML='';
1133                                         $flag=1;
1134                                 }
1135                                 $tablecode.='<td colspan="'.$colspan.'"><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$tableWidth.'" height="1" alt="" /></td>';
1136                                 if ($txtMarg && $align=='left') {       // If left aligned, the textborder is added on the left side
1137                                         $tablecode.='<td rowspan="'.($rowspan+1).'" valign="top"><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$txtMarg.'" height="1" alt="" title="" />'.($editIconsHTML?'<br />'.$editIconsHTML:'').'</td>';
1138                                         $editIconsHTML='';
1139                                         $flag=1;
1140                                 }
1141                                 if ($flag) $tableWidth+=$txtMarg+1;
1142         //                      $tableWidth=0;
1143                                 $tablecode.='</tr>';
1144                         }
1145
1146                                 // draw table
1147                         for ($c=0;$c<$rowCount;$c++) {  // Looping through rows. If 'noRows' is set, this is '1 time', but $rowCount_temp will hold the actual number of rows!
1148                                 if ($c && $rowspacing)  {               // If this is NOT the first time in the loop AND if space is required, a row-spacer is added. In case of "noRows" rowspacing is done further down.
1149                                         $tablecode.='<tr><td colspan="'.$colspan.'"><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="1" height="'.$rowspacing.'"'.$this->getBorderAttr(' border="0"').' alt="" title="" /></td></tr>';
1150                                 }
1151                                 $tablecode.='<tr>';     // starting row
1152                                 for ($b=0; $b<$colCount_temp; $b++)     {       // Looping through the columns
1153                                         if ($b && $colspacing)  {               // If this is NOT the first iteration AND if column space is required. In case of "noCols", the space is done without a separate cell.
1154                                                 if (!$noCols)   {
1155                                                         $tablecode.='<td><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$colspacing.'" height="1"'.$this->getBorderAttr(' border="0"').' alt="" title="" /></td>';
1156                                                 } else {
1157                                                         $colSpacer='<img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.($border?$colspacing-6:$colspacing).'" height="'.($imageRowsMaxHeights[$c]+($border?$borderThickness*2:0)).'"'.$this->getBorderAttr(' border="0"').' align="'.($border?'left':'top').'" alt="" title="" />';
1158                                                         $colSpacer='<td valign="top">'.$colSpacer.'</td>';      // added 160301, needed for the new "noCols"-table...
1159                                                         $tablecode.=$colSpacer;
1160                                                 }
1161                                         }
1162                                         if (!$noCols || ($noCols && !$b))       {
1163                                                 $tablecode.='<td valign="top">';        // starting the cell. If "noCols" this cell will hold all images in the row, otherwise only a single image.
1164                                                 if ($noCols)    {$tablecode.='<table width="'.$imageRowsFinalWidths[$c].'" border="0" cellpadding="0" cellspacing="0"><tr>';}           // In case of "noCols" we must set the table-tag that surrounds the images in the row.
1165                                         }
1166                                         for ($a=0;$a<$rowCount_temp;$a++)       {       // Looping through the rows IF "noRows" is set. "noRows"  means that the rows of images is not rendered by physical table rows but images are all in one column and spaced apart with clear-gifs. This loop is only one time if "noRows" is not set.
1167                                                 $GLOBALS['TSFE']->register['IMAGE_NUM'] = $imgIndex;    // register previous imgIndex
1168                                                 $imgIndex = $index+$a*$colCount_temp;
1169                                                 $GLOBALS['TSFE']->register['IMAGE_NUM_CURRENT'] = $imgIndex;
1170                                                 if ($imgsTag[$imgIndex])        {
1171                                                         if ($rowspacing && $noRows && $a) {             // Puts distance between the images IF "noRows" is set and this is the first iteration of the loop
1172                                                                 $tablecode.= '<img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="1" height="'.$rowspacing.'" alt="" title="" /><br />';
1173                                                         }
1174                                                         if ($legacyCaptionSplit)        {
1175                                                                 $thisCaption = $captionArray[$imgIndex];
1176                                                         } else if ($conf['captionSplit'] || $conf['imageTextSplit'])    {
1177                                                                 $thisCaption = $this->stdWrap($this->cObjGet($conf['caption.'], 'caption.'), $conf['caption.']);
1178                                                         }
1179                                                         $imageHTML = $imgsTag[$imgIndex].'<br />';
1180                                                         $Talign = (!trim($thisCaption) && !$noRows) ? ' align="left"' : '';  // this is necessary if the tablerows are supposed to space properly together! "noRows" is excluded because else the images "layer" together.
1181                                                         if ($border)    {$imageHTML='<table border="0" cellpadding="'.$borderThickness.'" cellspacing="0" bgcolor="'.$borderColor.'"'.$Talign.'><tr><td>'.$imageHTML.'</td></tr></table>';}
1182                                                         $imageHTML.=$editIconsHTML;
1183                                                         $editIconsHTML='';
1184                                                         $imageHTML.=$thisCaption;       // Adds caption.
1185                                                         if ($noCols)    {$imageHTML='<td valign="top">'.$imageHTML.'</td>';}            // If noCols, put in table cell.
1186                                                         $tablecode.=$imageHTML;
1187                                                 }
1188                                         }
1189                                         $index++;
1190                                         if (!$noCols || ($noCols && $b+1==$colCount_temp))      {
1191                                                 if ($noCols)    {$tablecode.='</tr></table>';}  // In case of "noCols" we must finish the table that surrounds the images in the row.
1192                                                 $tablecode.='</td>';    // Ending the cell. In case of "noCols" the cell holds all pictures!
1193                                         }
1194                                 }
1195                                 $tablecode.='</tr>';    // ending row
1196                         }
1197                         if ($c) {
1198                                 switch ($contentPosition)       {
1199                                         case '0':       // above
1200                                         case '8':       // below
1201                                                 switch ($align)        {        // These settings are needed for Firefox
1202                                                         case 'center':
1203                                                                 $table_align = 'margin-left: auto; margin-right: auto';
1204                                                         break;
1205                                                         case 'right':
1206                                                                 $table_align = 'margin-left: auto; margin-right: 0px';
1207                                                         break;
1208                                                         default:        // Most of all: left
1209                                                                 $table_align = 'margin-left: 0px; margin-right: auto';
1210                                                 }
1211                                                 $table_align = 'style="'.$table_align.'"';
1212                                         break;
1213                                         case '16':      // in text
1214                                                 $table_align = 'align="'.$align.'"';
1215                                         break;
1216                                         default:
1217                                                 $table_align = '';
1218                                 }
1219
1220                                         // Table-tag is inserted
1221                                 $tablecode = '<table'.($tableWidth?' width="'.$tableWidth.'"':'').' border="0" cellspacing="0" cellpadding="0" '.$table_align.' class="imgtext-table">'.$tablecode;
1222                                 if ($editIconsHTML)     {       // IF this value is not long since reset.
1223                                         $tablecode.='<tr><td colspan="'.$colspan.'">'.$editIconsHTML.'</td></tr>';
1224                                         $editIconsHTML='';
1225                                 }
1226                                 if ($cap)       {
1227                                         $tablecode.='<tr><td colspan="'.$colspan.'" align="'.$caption_align.'">'.$caption.'</td></tr>';
1228                                 }
1229                                 $tablecode.='</table>';
1230                                 if ($conf['tableStdWrap.'])     {$tablecode=$this->stdWrap($tablecode,$conf['tableStdWrap.']);}
1231                         }
1232
1233                         $spaceBelowAbove = intval($this->stdWrap($conf['spaceBelowAbove'],$conf['spaceBelowAbove.']));
1234                         switch ($contentPosition)       {
1235                                 case '0':       // above
1236                                         $output= '<div style="text-align:'.$align.';">'.$tablecode.'</div>'.$this->wrapSpace($content, $spaceBelowAbove.'|0');
1237                                 break;
1238                                 case '8':       // below
1239                                         $output= $this->wrapSpace($content, '0|'.$spaceBelowAbove).'<div style="text-align:'.$align.';">'.$tablecode.'</div>';
1240                                 break;
1241                                 case '16':      // in text
1242                                         $output= $tablecode.$content;
1243                                 break;
1244                                 case '24':      // in text, no wrap
1245                                         $theResult = '';
1246                                         $theResult.= '<table border="0" cellspacing="0" cellpadding="0" class="imgtext-nowrap"><tr>';
1247                                         if ($align=='right')    {
1248                                                 $theResult.= '<td valign="top">'.$content.'</td><td valign="top">'.$tablecode.'</td>';
1249                                         } else {
1250                                                 $theResult.= '<td valign="top">'.$tablecode.'</td><td valign="top">'.$content.'</td>';
1251                                         }
1252                                         $theResult.= '</tr></table>';
1253                                         $output= $theResult;
1254                                 break;
1255                         }
1256                 } else {
1257                         $output= $content;
1258                 }
1259
1260                 if ($conf['stdWrap.']) {
1261                         $output = $this->stdWrap($output, $conf['stdWrap.']);
1262                 }
1263
1264                 return $output;
1265         }
1266
1267         /**
1268          * Rendering the cObject, CONTENT
1269          *
1270          * @param       array           Array of TypoScript properties
1271          * @return      string          Output
1272          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=356&cHash=9f3b5c6ba2
1273          */
1274         function CONTENT($conf) {
1275                 $theValue='';
1276
1277                 $originalRec = $GLOBALS['TSFE']->currentRecord;
1278                 if ($originalRec)       {               // If the currentRecord is set, we register, that this record has invoked this function. It's should not be allowed to do this again then!!
1279                         $GLOBALS['TSFE']->recordRegister[$originalRec]++;
1280                 }
1281
1282                 if ($conf['table']=='pages' || substr($conf['table'],0,3)=='tt_' || substr($conf['table'],0,3)=='fe_' || substr($conf['table'],0,3)=='tx_' || substr($conf['table'],0,4)=='ttx_' || substr($conf['table'],0,5)=='user_' || substr($conf['table'],0,7)=='static_')       {
1283
1284                         $renderObjName = $conf['renderObj'] ? $conf['renderObj'] : '<'.$conf['table'];
1285                         $renderObjKey = $conf['renderObj'] ? 'renderObj' : '';
1286                         $renderObjConf = $conf['renderObj.'];
1287
1288                         $slide = intval($conf['slide'])?intval($conf['slide']):0;
1289                         $slideCollect = intval($conf['slide.']['collect'])?intval($conf['slide.']['collect']):0;
1290                         $slideCollectReverse = intval($conf['slide.']['collectReverse'])?true:false;
1291                         $slideCollectFuzzy = $slideCollect?(intval($conf['slide.']['collectFuzzy'])?true:false):true;
1292                         $again = false;
1293
1294                         do {
1295                                 $res = $this->exec_getQuery($conf['table'],$conf['select.']);
1296                                 if ($error = $GLOBALS['TYPO3_DB']->sql_error()) {
1297                                         $GLOBALS['TT']->setTSlogMessage($error,3);
1298                                 } else {
1299                                         $this->currentRecordTotal = $GLOBALS['TYPO3_DB']->sql_num_rows($res);
1300                                         $GLOBALS['TT']->setTSlogMessage('NUMROWS: '.$GLOBALS['TYPO3_DB']->sql_num_rows($res));
1301                                         $cObj =t3lib_div::makeInstance('tslib_cObj');
1302                                         $cObj->setParent($this->data,$this->currentRecord);
1303                                         $this->currentRecordNumber=0;
1304                                         $cobjValue = '';
1305                                         while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
1306
1307                                                         // Versioning preview:
1308                                                 $GLOBALS['TSFE']->sys_page->versionOL($conf['table'],$row,TRUE);
1309
1310                                                         // Language Overlay:
1311                                                 if (is_array($row) && $GLOBALS['TSFE']->sys_language_contentOL) {
1312                                                         $row = $GLOBALS['TSFE']->sys_page->getRecordOverlay($conf['table'],$row,$GLOBALS['TSFE']->sys_language_content,$GLOBALS['TSFE']->sys_language_contentOL);
1313                                                 }
1314
1315                                                 if (is_array($row)) { // Might be unset in the sys_language_contentOL
1316                                                         if (!$GLOBALS['TSFE']->recordRegister[$conf['table'].':'.$row['uid']]) {
1317                                                                 $this->currentRecordNumber++;
1318                                                                 $cObj->parentRecordNumber = $this->currentRecordNumber;
1319                                                                 $GLOBALS['TSFE']->currentRecord = $conf['table'].':'.$row['uid'];
1320                                                                 $this->lastChanged($row['tstamp']);
1321                                                                 $cObj->start($row,$conf['table']);
1322                                                                 $tmpValue = $cObj->cObjGetSingle($renderObjName, $renderObjConf, $renderObjKey);
1323                                                                 $cobjValue .= $tmpValue;
1324                                                         }
1325                                                 }
1326                                         }
1327                                         $GLOBALS['TYPO3_DB']->sql_free_result($res);
1328                                 }
1329                                 if ($slideCollectReverse) {
1330                                         $theValue = $cobjValue.$theValue;
1331                                 } else {
1332                                         $theValue .= $cobjValue;
1333                                 }
1334                                 if ($slideCollect>0) {
1335                                         $slideCollect--;
1336                                 }
1337                                 if ($slide) {
1338                                         if ($slide>0) {
1339                                                 $slide--;
1340                                         }
1341                                         $conf['select.']['pidInList'] = $this->getSlidePids($conf['select.']['pidInList'], $conf['select.']['pidInList.']);
1342                                         $again = strlen($conf['select.']['pidInList'])?true:false;
1343                                 }
1344                         } while ($again&&(($slide&&!strlen($tmpValue)&&$slideCollectFuzzy)||($slide&&$slideCollect)));
1345                 }
1346
1347                 $theValue = $this->wrap($theValue,$conf['wrap']);
1348                 if ($conf['stdWrap.']) $theValue = $this->stdWrap($theValue,$conf['stdWrap.']);
1349
1350                 $GLOBALS['TSFE']->currentRecord = $originalRec; // Restore
1351                 return $theValue;
1352         }
1353
1354         /**
1355          * Rendering the cObject, RECORDS
1356          *
1357          * @param       array           Array of TypoScript properties
1358          * @return      string          Output
1359          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=357&cHash=303e959472
1360          */
1361         function RECORDS($conf) {
1362                 $theValue='';
1363
1364                 $originalRec = $GLOBALS['TSFE']->currentRecord;
1365                 if ($originalRec)       {               // If the currentRecord is set, we register, that this record has invoked this function. It's should not be allowed to do this again then!!
1366                         $GLOBALS['TSFE']->recordRegister[$originalRec]++;
1367                 }
1368
1369                 $conf['source'] = $this->stdWrap($conf['source'],$conf['source.']);
1370                 if ($conf['tables'] && $conf['source']) {
1371                         $allowedTables = $conf['tables'];
1372                         if (is_array($conf['conf.']))   {
1373                                 reset($conf['conf.']);
1374                                 while(list($k)=each($conf['conf.']))    {
1375                                         if (substr($k,-1)!='.')         $allowedTables.=','.$k;
1376                                 }
1377                         }
1378
1379                         $loadDB = t3lib_div::makeInstance('FE_loadDBGroup');
1380                         $loadDB->start($conf['source'], $allowedTables);
1381                         reset($loadDB->tableArray);
1382                         while(list($table,)=each($loadDB->tableArray))  {
1383                                 if (is_array($GLOBALS['TCA'][$table]))  {
1384                                         $loadDB->additionalWhere[$table]=$this->enableFields($table);
1385                                 }
1386                         }
1387                         $loadDB->getFromDB();
1388
1389                         reset($loadDB->itemArray);
1390                         $data = $loadDB->results;
1391
1392                         $cObj =t3lib_div::makeInstance('tslib_cObj');
1393                         $cObj->setParent($this->data,$this->currentRecord);
1394                         $this->currentRecordNumber=0;
1395                         $this->currentRecordTotal = count($loadDB->itemArray);
1396                         reset($loadDB->itemArray);
1397                         while(list(,$val)=each($loadDB->itemArray))     {
1398                                 $row = $data[$val['table']][$val['id']];
1399
1400                                         // Versioning preview:
1401                                 $GLOBALS['TSFE']->sys_page->versionOL($val['table'],$row);
1402
1403                                         // Language Overlay:
1404                                 if (is_array($row) && $GLOBALS['TSFE']->sys_language_contentOL) {
1405                                         $row = $GLOBALS['TSFE']->sys_page->getRecordOverlay($val['table'],$row,$GLOBALS['TSFE']->sys_language_content,$GLOBALS['TSFE']->sys_language_contentOL);
1406                                 }
1407
1408                                 if (is_array($row))     {       // Might be unset in the content overlay things...
1409                                         if (!$conf['dontCheckPid'])     {
1410                                                 $row = $this->checkPid($row['pid']) ? $row : '';
1411                                         }
1412                                         if ($row && !$GLOBALS['TSFE']->recordRegister[$val['table'].':'.$val['id']])    {
1413                                                 $renderObjName = $conf['conf.'][$val['table']] ? $conf['conf.'][$val['table']] : '<'.$val['table'];
1414                                                 $renderObjKey = $conf['conf.'][$val['table']] ? 'conf.'.$val['table'] : '';
1415                                                 $renderObjConf = $conf['conf.'][$val['table'].'.'];
1416                                                 $this->currentRecordNumber++;
1417                                                 $cObj->parentRecordNumber=$this->currentRecordNumber;
1418                                                 $GLOBALS['TSFE']->currentRecord = $val['table'].':'.$val['id'];
1419                                                 $this->lastChanged($row['tstamp']);
1420                                                 $cObj->start($row,$val['table']);
1421                                                 $tmpValue = $cObj->cObjGetSingle($renderObjName, $renderObjConf, $renderObjKey);
1422                                                 $theValue .= $tmpValue;
1423                                         }# else debug($GLOBALS['TSFE']->recordRegister,'RECORDS');
1424                                 }
1425                         }
1426                 }
1427                 if ($conf['wrap'])      $theValue = $this->wrap($theValue,$conf['wrap']);
1428                 if ($conf['stdWrap.'])  $theValue = $this->stdWrap($theValue,$conf['stdWrap.']);
1429
1430                 $GLOBALS['TSFE']->currentRecord = $originalRec; // Restore
1431                 return $theValue;
1432         }
1433
1434         /**
1435          * Rendering the cObject, HMENU
1436          *
1437          * @param       array           Array of TypoScript properties
1438          * @return      string          Output
1439          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=358&cHash=5400c1c06a
1440          */
1441         function HMENU($conf)   {
1442                 $content='';
1443                 if ($this->checkIf($conf['if.']))       {
1444                         $cls = strtolower($conf[1]);
1445                         if (t3lib_div::inList($GLOBALS['TSFE']->tmpl->menuclasses,$cls))        {
1446                                 if ($conf['special.']['value.'])        {
1447                                         $conf['special.']['value']  = $this->stdWrap($conf['special.']['value'], $conf['special.']['value.']);
1448                                 }
1449                                 $GLOBALS['TSFE']->register['count_HMENU']++;
1450                                 $GLOBALS['TSFE']->register['count_HMENU_MENUOBJ']=0;
1451                                 $GLOBALS['TSFE']->applicationData['GMENU_LAYERS']['WMid']=array();
1452                                 $GLOBALS['TSFE']->applicationData['GMENU_LAYERS']['WMparentId']=array();
1453
1454                                 $menu = t3lib_div::makeInstance('tslib_'.$cls);
1455                                 $menu->parent_cObj = $this;
1456                                 $menu->start($GLOBALS['TSFE']->tmpl, $GLOBALS['TSFE']->sys_page, '', $conf, 1);
1457                                 $menu->makeMenu();
1458                                 $content.=$menu->writeMenu();
1459                         }
1460                         if ($conf['wrap'])              $content=$this->wrap($content, $conf['wrap']);
1461                         if ($conf['stdWrap.'])  $content = $this->stdWrap($content, $conf['stdWrap.']);
1462                 }
1463                 return $content;
1464         }
1465
1466         /**
1467          * Rendering the cObject, CTABLE
1468          *
1469          * @param       array           Array of TypoScript properties
1470          * @return      string          Output
1471          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=359&cHash=2e0065b4e7
1472          */
1473         function CTABLE ($conf) {
1474                 $controlTable = t3lib_div::makeInstance('tslib_controlTable');
1475                         if ($conf['tableParams'])       {
1476                         $controlTable->tableParams = $conf['tableParams'];
1477                 }
1478                         // loads the pagecontent
1479                 $controlTable->contentW = $conf['cWidth'];
1480                         // loads the menues if any
1481                 if (is_array($conf['c.']))      {
1482                         $controlTable->content = $this->cObjGet($conf['c.'],'c.');
1483                         $controlTable->contentTDparams = isset($conf['c.']['TDParams']) ? $conf['c.']['TDParams'] : 'valign="top"';
1484                 }
1485                 if (is_array($conf['lm.']))     {
1486                         $controlTable->lm = $this->cObjGet($conf['lm.'],'lm.');
1487                         $controlTable->lmTDparams = isset($conf['lm.']['TDParams']) ? $conf['lm.']['TDParams'] : 'valign="top"';
1488                 }
1489                 if (is_array($conf['tm.']))     {
1490                         $controlTable->tm = $this->cObjGet($conf['tm.'],'tm.');
1491                         $controlTable->tmTDparams = isset($conf['tm.']['TDParams']) ? $conf['tm.']['TDParams'] : 'valign="top"';
1492                 }
1493                 if (is_array($conf['rm.']))     {
1494                         $controlTable->rm = $this->cObjGet($conf['rm.'],'rm.');
1495                         $controlTable->rmTDparams = isset($conf['rm.']['TDParams']) ? $conf['rm.']['TDParams'] : 'valign="top"';
1496                 }
1497                 if (is_array($conf['bm.']))     {
1498                         $controlTable->bm = $this->cObjGet($conf['bm.'],'bm.');
1499                         $controlTable->bmTDparams = isset($conf['bm.']['TDParams']) ? $conf['bm.']['TDParams'] : 'valign="top"';
1500                 }
1501                 return $controlTable->start($conf['offset'],$conf['cMargins']);
1502         }
1503
1504         /**
1505          * Rendering the cObject, OTABLE
1506          *
1507          * @param       array           Array of TypoScript properties
1508          * @return      string          Output
1509          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=360&cHash=02c9552d38
1510          */
1511         function OTABLE ($conf) {
1512                 $controlTable = t3lib_div::makeInstance('tslib_tableOffset');
1513                 if ($conf['tableParams'])       {
1514                         $controlTable->tableParams = $conf['tableParams'];
1515                 }
1516                 return $controlTable->start($this->cObjGet($conf),$conf['offset']);
1517         }
1518
1519         /**
1520          * Rendering the cObject, COLUMNS
1521          *
1522          * @param       array           Array of TypoScript properties
1523          * @return      string          Output
1524          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=361&cHash=7e4e228cad
1525          */
1526         function COLUMNS ($conf)        {
1527                 $content='';
1528                 if (is_array($conf) && $this->checkIf($conf['if.']))    {
1529                         $tdRowCount=0;
1530                         $tableParams = $conf['tableParams'] ? ' '.$conf['tableParams'] : ' border="0" cellspacing="0" cellpadding="0"';
1531                         $TDparams = $conf['TDparams'] ? ' '.$conf['TDparams']:' valign="top"';
1532                         $rows = t3lib_div::intInRange($conf['rows'],2,20);
1533                         $totalWidth = intval($conf['totalWidth']);
1534                         $columnWidth=0;
1535
1536                         $totalGapWidth=0;
1537                         $gapData = Array(
1538                                 'gapWidth' => $this->stdWrap($conf['gapWidth'],$conf['gapWidth.']),
1539                                 'gapBgCol' => $this->stdWrap($conf['gapBgCol'],$conf['gapBgCol.']),
1540                                 'gapLineThickness' => $this->stdWrap($conf['gapLineThickness'],$conf['gapLineThickness.']),
1541                                 'gapLineCol' => $this->stdWrap($conf['gapLineCol'],$conf['gapLineCol.'])
1542                         );
1543                         $gapData = $GLOBALS['TSFE']->tmpl->splitConfArray($gapData,$rows-1);
1544                         reset($gapData);
1545                         while(list(,$val)=each($gapData))       {
1546                                 $totalGapWidth+=intval($val['gapWidth']);
1547                         }
1548
1549                         if ($totalWidth)        {
1550                                 $columnWidth = ceil(($totalWidth-$totalGapWidth)/$rows);
1551                                 $TDparams.=' width="'.$columnWidth.'"';
1552                                 $tableParams.=' width="'.$totalWidth.'"';
1553                         } else {
1554                                 $TDparams.=' width="'.floor(100/$rows).'%"';
1555                                 $tableParams.=' width="100%"';
1556                         }
1557
1558                         for ($a=1;$a<=$rows;$a++)       {
1559                                 $tdRowCount++;
1560                                 $content.='<td'.$TDparams.'>';
1561                                 $content.=$this->cObjGetSingle($conf[$a],$conf[$a.'.'], $a);
1562                                 $content.='</td>';
1563                                 if ($a < $rows) {
1564                                         $gapConf = $gapData[($a-1)];
1565                                         $gapWidth = intval($gapConf['gapWidth']);
1566                                         if ($gapWidth)  {
1567                                                 $tdPar = $gapConf['gapBgCol'] ? ' bgcolor="'.$gapConf['gapBgCol'].'"' : '';
1568                                                 $gapLine = intval($gapConf['gapLineThickness']);
1569                                                 if ($gapLine)   {
1570                                                         $gapSurround = t3lib_div::intInRange(($gapWidth-$gapLine)/2, 1, 1000);
1571                                                                 // right gap
1572                                                         $content.='<td'.$tdPar.'><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$gapSurround.'" height="1" alt="" title="" /></td>';
1573                                                         $tdRowCount++;
1574                                                                 // line:
1575                                                         $GtdPar = $gapConf['gapLineCol'] ? ' bgcolor="'.$gapConf['gapLineCol'].'"' : ' bgcolor="black"';
1576                                                         $content.='<td'.$GtdPar.'><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$gapLine.'" height="1" alt="" title="" /></td>';
1577                                                         $tdRowCount++;
1578                                                                 // left gap
1579                                                         $content.='<td'.$tdPar.'><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$gapSurround.'" height="1" alt="" title="" /></td>';
1580                                                         $tdRowCount++;
1581                                                 } else {
1582                                                         $content.='<td'.$tdPar.'><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$gapWidth.'" height="1" alt="" title="" /></td>';
1583                                                         $tdRowCount++;
1584                                                 }
1585                                         }
1586                                 }
1587                         }
1588                         $content = '<tr>'.$content.'</tr>';
1589                         $content = '<table'.$tableParams.'>'.$content.'</table>';
1590                         $content.= $this->cObjGetSingle($conf['after'],$conf['after.'], 'after');
1591                         if ($conf['stdWrap.'])  {
1592                                 $content = $this->stdWrap($content,$conf['stdWrap.']);
1593                         }
1594                 }
1595                 return $content;
1596         }
1597
1598         /**
1599          * Rendering the cObject, HRULER
1600          *
1601          * @param       array           Array of TypoScript properties
1602          * @return      string          Output
1603          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=362&cHash=2a462aa084
1604          */
1605         function HRULER ($conf) {
1606                 $lineThickness = t3lib_div::intInRange($this->stdWrap($conf['lineThickness'],$conf['lineThickness.']),1,50);
1607                 $lineColor = $conf['lineColor'] ? $conf['lineColor'] : 'black';
1608                 $spaceBefore = intval($conf['spaceLeft']);
1609                 $spaceAfter = intval($conf['spaceRight']);
1610                 $tableWidth = $conf['tableWidth'] ? $conf['tableWidth'] : '99%';
1611                 $content='';
1612
1613                 $content.='<table border="0" cellspacing="0" cellpadding="0" width="'.htmlspecialchars($tableWidth).'" summary=""><tr>';
1614                 if ($spaceBefore)       {$content.='<td width="1"><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$spaceBefore.'" height="1" alt="" title="" /></td>'; }
1615                 $content.='<td bgcolor="'.$lineColor.'"><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="1" height="'.$lineThickness.'" alt="" title="" /></td>';
1616                 if ($spaceAfter)        {$content.='<td width="1"><img src="'.$GLOBALS['TSFE']->absRefPrefix.'clear.gif" width="'.$spaceAfter.'" height="1" alt="" title="" /></td>'; }
1617                 $content.='</tr></table>';
1618
1619                 $content = $this->stdWrap($content, $conf['stdWrap.']);
1620                 return $content;
1621         }
1622
1623         /**
1624          * Rendering the cObject, CASE
1625          *
1626          * @param       array           Array of TypoScript properties
1627          * @return      string          Output
1628          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=364&cHash=cffedd09e3
1629          */
1630         function CASEFUNC ($conf){
1631                 $content='';
1632                 if ($this->checkIf($conf['if.']))       {
1633                         if ($conf['setCurrent'] || $conf['setCurrent.']){$this->data[$this->currentValKey] = $this->stdWrap($conf['setCurrent'], $conf['setCurrent.']);}
1634                         $key = $this->stdWrap($conf['key'],$conf['key.']);
1635                         $key = strlen($conf[$key]) ? $key : 'default';
1636                         $name = $conf[$key];
1637                         $theValue = $this->cObjGetSingle($name,$conf[$key.'.'], $key);
1638                         if ($conf['stdWrap.'])  {
1639                                 $theValue = $this->stdWrap($theValue,$conf['stdWrap.']);
1640                         }
1641                         return $theValue;
1642                 }
1643         }
1644
1645         /**
1646          * Rendering the cObject, LOAD_REGISTER and RESTORE_REGISTER
1647          * NOTICE: This cObject does NOT return any content since it just sets internal data based on the TypoScript properties.
1648          *
1649          * @param       array           Array of TypoScript properties
1650          * @param       string          If "RESTORE_REGISTER" then the cObject rendered is "RESTORE_REGISTER", otherwise "LOAD_REGISTER"
1651          * @return      string          Empty string (the cObject only sets internal data!)
1652          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=365&cHash=4935524e2e
1653          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=366&cHash=4f9485e8cc
1654          */
1655         function LOAD_REGISTER($conf,$name)     {
1656                 if ($name=='RESTORE_REGISTER')  {
1657                         $GLOBALS['TSFE']->register = array_pop($GLOBALS['TSFE']->registerStack);
1658                 } else {
1659                         array_push($GLOBALS['TSFE']->registerStack,$GLOBALS['TSFE']->register);
1660                         if (is_array($conf))    {
1661                                 reset($conf);
1662                                 while(list($theKey,$theValue)=each($conf))      {
1663                                         if (!strstr($theKey,'.') || !isset($conf[substr($theKey,0,-1)]))        {               // Only if 1) the property is set but not the value itself, 2) the value and/or any property
1664                                                 if (strstr($theKey,'.'))        {
1665                                                         $theKey = substr($theKey,0,-1);
1666                                                 }
1667                                                 $GLOBALS['TSFE']->register[$theKey] = $this->stdWrap($conf[$theKey],$conf[$theKey.'.']);
1668                                         }
1669                                 }
1670                         }
1671                 }
1672                 return '';
1673         }
1674
1675         /**
1676          * Rendering the cObject, FORM
1677          *
1678          * Note on $formData:
1679          * In the optional $formData array each entry represents a line in the ordinary setup.
1680          * In those entries each entry (0,1,2...) represents a space normally divided by the '|' line.
1681          *
1682          * $formData [] = array('Name:', 'name=input, 25 ', 'Default value....');
1683          * $formData [] = array('Email:', 'email=input, 25 ', 'Default value for email....');
1684          *
1685          * - corresponds to the $conf['data'] value being :
1686          * Name:|name=input, 25 |Default value....||Email:|email=input, 25 |Default value for email....
1687          *
1688          * If $formData is an array the value of $conf['data'] is ignored.
1689          *
1690          * @param       array           Array of TypoScript properties
1691          * @param       array           Alternative formdata overriding whatever comes from TypoScript
1692          * @return      string          Output
1693          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=367&cHash=bbc518d930
1694          */
1695         function FORM($conf,$formData='') {
1696                 $content='';
1697                 if (is_array($formData)) {
1698                         $dataArr = $formData;
1699                 } else {
1700                         $data = $this->stdWrap($conf['data'],$conf['data.']);
1701                                 // Clearing dataArr
1702                         $dataArr = array();
1703                                 // Getting the original config
1704                         if (trim($data))        {
1705                                 $data = str_replace(chr(10),'||',$data);
1706                                 $dataArr = explode('||',$data);
1707                         }
1708                                 // Adding the new dataArray config form:
1709                         if (is_array($conf['dataArray.'])) {    // dataArray is supplied
1710                                 $sKeyArray = t3lib_TStemplate::sortedKeyList($conf['dataArray.'], TRUE);
1711                                 foreach ($sKeyArray as $theKey) {
1712                                         $dAA = $conf['dataArray.'][$theKey.'.'];
1713                                         if (is_array($dAA))     {
1714                                                 $temp = array();
1715                                                 list($temp[0]) = explode('|',$dAA['label.'] ? $this->stdWrap($dAA['label'],$dAA['label.']) : $dAA['label']);
1716                                                 list($temp[1]) = explode('|',$dAA['type']);
1717                                                 if ($dAA['required']) {
1718                                                         $temp[1] = '*'.$temp[1];
1719                                                 }
1720                                                 list($temp[2]) = explode('|',$dAA['value.'] ? $this->stdWrap($dAA['value'],$dAA['value.']) : $dAA['value']);
1721                                                         // If value Array is set, then implode those values.
1722                                                 if (is_array($dAA['valueArray.'])) {
1723                                                         reset($dAA['valueArray.']);
1724                                                         $temp_accum = array();
1725                                                         while (list($dAKey_vA,$dAA_vA) = each($dAA['valueArray.']))     {
1726                                                                 if (is_array($dAA_vA) && !strcmp(intval($dAKey_vA).'.',$dAKey_vA))      {
1727                                                                         $temp_vA=array();
1728                                                                         list($temp_vA[0])= explode('=',$dAA_vA['label.'] ? $this->stdWrap($dAA_vA['label'],$dAA_vA['label.']) : $dAA_vA['label']);
1729                                                                         if ($dAA_vA['selected'])        {$temp_vA[0]='*'.$temp_vA[0];}
1730                                                                         list($temp_vA[1])= explode(',',$dAA_vA['value']);
1731                                                                 }
1732                                                                 $temp_accum[] = implode('=',$temp_vA);
1733                                                         }
1734                                                         $temp[2] = implode(',',$temp_accum);
1735                                                 }
1736                                                 list($temp[3]) = explode('|',$dAA['specialEval.'] ? $this->stdWrap($dAA['specialEval'],$dAA['specialEval.']) : $dAA['specialEval']);
1737
1738                                                         // adding the form entry to the dataArray
1739                                                 $dataArr[] = implode('|',$temp);
1740                                         }
1741                                 }
1742                         }
1743                 }
1744
1745                 $attachmentCounter = '';
1746                 $hiddenfields = '';
1747                 $fieldlist = Array();
1748                 $propertyOverride = Array();
1749                 $fieldname_hashArray = Array();
1750                 $cc = 0;
1751
1752                 $xhtmlStrict = t3lib_div::inList('xhtml_strict,xhtml_11,xhtml_2',$GLOBALS['TSFE']->xhtmlDoctype);
1753                         // Formname
1754                 if ($conf['formName']) {
1755                         $formname = $this->cleanFormName($conf['formName']);
1756                 } else {
1757                         $formname = $GLOBALS['TSFE']->uniqueHash();
1758                         $formname = 'a'.$formname;      // form name has to start with a letter to reach XHTML compliance
1759                 }
1760
1761                 if (isset($conf['fieldPrefix'])) {
1762                         if ($conf['fieldPrefix']) {
1763                                 $prefix = $this->cleanFormName($conf['fieldPrefix']);
1764                         } else {
1765                                 $prefix = '';
1766                         }
1767                 } else {
1768                         $prefix = $formname;
1769                 }
1770
1771                 foreach ($dataArr as $val)      {
1772
1773                         $cc++;
1774                         $confData=Array();
1775                         if (is_array($formData)) {
1776                                 $parts = $val;
1777                                 $val = 1;    // true...
1778                         } else {
1779                                 $val = trim($val);
1780                                 $parts = explode('|',$val);
1781                         }
1782                         if ($val && strcspn($val,'#/')) {
1783                                         // label:
1784                                 $confData['label'] = trim($parts[0]);
1785                                         // field:
1786                                 $fParts = explode(',',$parts[1]);
1787                                 $fParts[0]=trim($fParts[0]);
1788                                 if (substr($fParts[0],0,1)=='*')        {
1789                                         $confData['required']=1;
1790                                         $fParts[0] = substr($fParts[0],1);
1791                                 }
1792                                 $typeParts = explode('=',$fParts[0]);
1793                                 $confData['type'] = trim(strtolower(end($typeParts)));
1794                                 if (count($typeParts)==1)       {
1795                                         $confData['fieldname'] = $this->cleanFormName($parts[0]);
1796                                         if (strtolower(ereg_replace('[^[:alnum:]]','',$confData['fieldname']))=='email')        {$confData['fieldname']='email';}
1797                                                 // Duplicate fieldnames resolved
1798                                         if (isset($fieldname_hashArray[md5($confData['fieldname'])]))   {
1799                                                 $confData['fieldname'].='_'.$cc;
1800                                         }
1801                                         $fieldname_hashArray[md5($confData['fieldname'])]=$confData['fieldname'];
1802                                                 // Attachment names...
1803                                         if ($confData['type']=='file')  {
1804                                                 $confData['fieldname']='attachment'.$attachmentCounter;
1805                                                 $attachmentCounter=intval($attachmentCounter)+1;
1806                                         }
1807                                 } else {
1808                                         $confData['fieldname'] = str_replace(' ','_',trim($typeParts[0]));
1809                                 }
1810                                 $fieldCode='';
1811
1812                                 if ($conf['wrapFieldName'])     {
1813                                         $confData['fieldname'] = $this->wrap($confData['fieldname'],$conf['wrapFieldName']);
1814                                 }
1815
1816                                         // Set field name as current:
1817                                 $this->setCurrentVal($confData['fieldname']);
1818
1819                                         // Additional parameters
1820                                 if (trim($confData['type']))    {
1821                                         $addParams=trim($conf['params']);
1822                                         if (is_array($conf['params.']) && isset($conf['params.'][$confData['type']]))   {
1823                                                 $addParams=trim($conf['params.'][$confData['type']]);
1824                                         }
1825                                         if (strcmp('',$addParams))      { $addParams=' '.$addParams; }
1826                                 } else $addParams='';
1827
1828                                 if ($conf['dontMd5FieldNames']) {
1829                                         $fName = $confData['fieldname'];
1830                                 } else {
1831                                         $fName = md5($confData['fieldname']);
1832                                 }
1833
1834                                         // Accessibility: Set id = fieldname attribute:
1835                                 if ($conf['accessibility'] || $xhtmlStrict)     {
1836                                         $elementIdAttribute = ' id="'.$prefix.$fName.'"';
1837                                 } else {
1838                                         $elementIdAttribute = '';
1839                                 }
1840
1841                                         // Create form field based on configuration/type:
1842                                 switch ($confData['type'])      {
1843                                         case 'textarea':
1844                                                 $cols=trim($fParts[1]) ? intval($fParts[1]) : 20;
1845                                                 $compWidth = doubleval($conf['compensateFieldWidth'] ? $conf['compensateFieldWidth'] : $GLOBALS['TSFE']->compensateFieldWidth);
1846                                                 $compWidth = $compWidth ? $compWidth : 1;
1847                                                 $cols = t3lib_div::intInRange($cols*$compWidth, 1, 120);
1848
1849                                                 $rows=trim($fParts[2]) ? t3lib_div::intInRange($fParts[2],1,30) : 5;
1850                                                 $wrap=trim($fParts[3]);
1851                                                 if ($conf['noWrapAttr'] || $wrap === 'disabled')        {
1852                                                         $wrap='';
1853                                                 } else {
1854                                                         $wrap = $wrap ? ' wrap="'.$wrap.'"' : ' wrap="virtual"';
1855                                                 }
1856                                                 $default = $this->getFieldDefaultValue($conf['noValueInsert'], $confData['fieldname'], str_replace('\n',chr(10),trim($parts[2])));
1857                                                 $fieldCode=sprintf('<textarea name="%s"%s cols="%s" rows="%s"%s%s>%s</textarea>',
1858                                                         $confData['fieldname'], $elementIdAttribute, $cols, $rows, $wrap, $addParams, t3lib_div::formatForTextarea($default));
1859                                         break;
1860                                         case 'input':
1861                                         case 'password':
1862                                                 $size=trim($fParts[1]) ? intval($fParts[1]) : 20;
1863                                                 $compWidth = doubleval($conf['compensateFieldWidth'] ? $conf['compensateFieldWidth'] : $GLOBALS['TSFE']->compensateFieldWidth);
1864                                                 $compWidth = $compWidth ? $compWidth : 1;
1865                                                 $size = t3lib_div::intInRange($size*$compWidth, 1, 120);
1866                                                 $default = $this->getFieldDefaultValue($conf['noValueInsert'], $confData['fieldname'], trim($parts[2]));
1867
1868                                                 if ($confData['type']=='password')      {
1869                                                         $default='';
1870                                                 }
1871
1872                                                 $max=trim($fParts[2]) ? ' maxlength="'.t3lib_div::intInRange($fParts[2],1,1000).'"' : "";
1873                                                 $theType = $confData['type']=='input' ? 'text' : 'password';
1874
1875                                                 $fieldCode=sprintf('<input type="%s" name="%s"%s size="%s"%s value="%s"%s />',
1876                                                         $theType, $confData['fieldname'], $elementIdAttribute, $size, $max, htmlspecialchars($default), $addParams);
1877
1878                                         break;
1879                                         case 'file':
1880                                                 $size=trim($fParts[1]) ? t3lib_div::intInRange($fParts[1],1,60) : 20;
1881                                                 $fieldCode=sprintf('<input type="file" name="%s"%s size="%s"%s />',
1882                                                         $confData['fieldname'], $elementIdAttribute, $size, $addParams);
1883                                         break;
1884                                         case 'check':
1885                                                         // alternative default value:
1886                                                 $default = $this->getFieldDefaultValue($conf['noValueInsert'], $confData['fieldname'], trim($parts[2]));
1887                                                 $checked = $default ? ' checked="checked"' : '';
1888                                                 $fieldCode=sprintf('<input type="checkbox" value="%s" name="%s"%s%s%s />',
1889                                                         1, $confData['fieldname'], $elementIdAttribute, $checked, $addParams);
1890                                         break;
1891                                         case 'select':
1892                                                 $option='';
1893                                                 $valueParts = explode(',',$parts[2]);
1894                                                         // size
1895                                                 if (strtolower(trim($fParts[1]))=='auto')       {$fParts[1]=count($valueParts);}                // Auto size set here. Max 20
1896                                                 $size=trim($fParts[1]) ? t3lib_div::intInRange($fParts[1],1,20) : 1;
1897                                                         // multiple
1898                                                 $multiple = strtolower(trim($fParts[2]))=='m' ? ' multiple="multiple"' : '';
1899
1900                                                 $items=array();         // Where the items will be
1901                                                 $defaults=array(); //RTF
1902                                                 $pCount = count($valueParts);
1903                                                 for($a=0;$a<$pCount;$a++)       {
1904                                                         $valueParts[$a]=trim($valueParts[$a]);
1905                                                         if (substr($valueParts[$a],0,1)=='*')   {       // Finding default value
1906                                                                 $sel='selected';
1907                                                                 $valueParts[$a] = substr($valueParts[$a],1);
1908                                                         } else $sel='';
1909                                                                 // Get value/label
1910                                                         $subParts=explode('=',$valueParts[$a]);
1911                                                         $subParts[1] = (isset($subParts[1])?trim($subParts[1]):trim($subParts[0]));             // Sets the value
1912                                                         $items[] = $subParts;   // Adds the value/label pair to the items-array
1913                                                         if ($sel) {$defaults[]=$subParts[1];}   // Sets the default value if value/label pair is marked as default.
1914                                                 }
1915                                                         // alternative default value:
1916                                                 $default = $this->getFieldDefaultValue($conf['noValueInsert'], $confData['fieldname'], $defaults);
1917                                                 if (!is_array($default)) {
1918                                                         $defaults=array();
1919                                                         $defaults[] = $default;
1920                                                 } else $defaults=$default;
1921                                                         // Create the select-box:
1922                                                 $iCount = count($items);
1923                                                 for($a=0;$a<$iCount;$a++)       {
1924                                                         $option.='<option value="'.$items[$a][1].'"'.(in_array($items[$a][1],$defaults)?' selected="selected"':'').'>'.trim($items[$a][0]).'</option>'; //RTF
1925                                                 }
1926
1927                                                 if ($multiple)  $confData['fieldname'].='[]';   // The fieldname must be prepended '[]' if multiple select. And the reason why it's prepended is, because the required-field list later must also have [] prepended.
1928                                                 $fieldCode=sprintf('<select name="%s"%s size="%s"%s%s>%s</select>',
1929                                                         $confData['fieldname'], $elementIdAttribute, $size, $multiple, $addParams, $option); //RTF
1930                                         break;
1931                                         case 'radio':
1932                                                 $option='';
1933
1934                                                 $valueParts = explode(',',$parts[2]);
1935                                                 $items=array();         // Where the items will be
1936                                                 $default='';
1937                                                 $pCount = count($valueParts);
1938                                                 for($a=0;$a<$pCount;$a++)       {
1939                                                         $valueParts[$a]=trim($valueParts[$a]);
1940                                                         if (substr($valueParts[$a],0,1)=='*')   {
1941                                                                 $sel='checked';
1942                                                                 $valueParts[$a] = substr($valueParts[$a],1);
1943                                                         } else $sel='';
1944                                                                 // Get value/label
1945                                                         $subParts=explode('=',$valueParts[$a]);
1946                                                         $subParts[1] = (isset($subParts[1])?trim($subParts[1]):trim($subParts[0]));             // Sets the value
1947                                                         $items[] = $subParts;   // Adds the value/label pair to the items-array
1948                                                         if ($sel) {$default=$subParts[1];}      // Sets the default value if value/label pair is marked as default.
1949                                                 }
1950                                                         // alternative default value:
1951                                                 $default = $this->getFieldDefaultValue($conf['noValueInsert'], $confData['fieldname'], $default);
1952                                                         // Create the select-box:
1953                                                 $iCount = count($items);
1954                                                 for($a=0;$a<$iCount;$a++)       {
1955                                                         $radioId = $prefix.$fName.$this->cleanFormName($items[$a][0]);
1956                                                         if ($conf['accessibility'])     {
1957                                                                 $radioLabelIdAttribute = ' id="'.$radioId.'"';
1958                                                         } else {
1959                                                                 $radioLabelIdAttribute = '';
1960                                                         }
1961                                                         $option .= '<input type="radio" name="'.$confData['fieldname'].'"'.$radioLabelIdAttribute.' value="'.$items[$a][1].'"'.(!strcmp($items[$a][1],$default)?' checked="checked"':'').$addParams.' />';
1962                                                         if ($conf['accessibility'])     {
1963                                                                 $option .= '<label for="'.$radioId.'">' . $this->stdWrap(trim($items[$a][0]), $conf['radioWrap.']) . '</label>';
1964                                                         } else {
1965                                                                 $option .= $this->stdWrap(trim($items[$a][0]), $conf['radioWrap.']);
1966                                                         }
1967                                                 }
1968
1969                                                 if ($conf['accessibility'])     {
1970                                                         $accessibilityWrap = $conf['radioWrap.']['accessibilityWrap'];
1971
1972                                                         $search = array(
1973                                                                 '###RADIO_FIELD_ID###',
1974                                                                 '###RADIO_GROUP_LABEL###'
1975                                                         );
1976                                                         $replace = array(
1977                                                                 $elementIdAttribute,
1978                                                                 $confData['label']
1979                                                         );
1980                                                         $accessibilityWrap = str_replace($search, $replace, $accessibilityWrap);
1981
1982                                                         $option = $this->wrap($option, $accessibilityWrap);
1983                                                 }
1984
1985                                                 $fieldCode = $option;
1986                                         break;
1987                                         case 'hidden':
1988                                                 $value = trim($parts[2]);
1989                                                 if (strlen($value) && t3lib_div::inList('recipient_copy,recipient',$confData['fieldname']) && $GLOBALS['TYPO3_CONF_VARS']['FE']['secureFormmail'])      {
1990                                                         break;
1991                                                 }
1992                                                 if (strlen($value) && t3lib_div::inList('recipient_copy,recipient',$confData['fieldname']))     {
1993                                                         $value = $GLOBALS['TSFE']->codeString($value);
1994                                                 }
1995                                                 $hiddenfields.= sprintf('<input type="hidden" name="%s"%s value="%s" />',
1996                                                         $confData['fieldname'], $elementIdAttribute, htmlspecialchars($value));
1997                                         break;
1998                                         case 'property':
1999                                                 if (t3lib_div::inList('type,locationData,goodMess,badMess,emailMess',$confData['fieldname']))   {
2000                                                         $value=trim($parts[2]);
2001                                                         $propertyOverride[$confData['fieldname']] = $value;
2002                                                         $conf[$confData['fieldname']] = $value;
2003                                                 }
2004                                         break;
2005                                         case 'submit':
2006                                                 $value=trim($parts[2]);
2007                                                 if ($conf['image.'])    {
2008                                                         $this->data[$this->currentValKey] = $value;
2009                                                         $image = $this->IMG_RESOURCE($conf['image.']);
2010                                                         $params = $conf['image.']['params'] ? ' '.$conf['image.']['params'] : '';
2011                                                         $params.= $this->getAltParam($conf['image.'], false);
2012                                                         $params.= $addParams;
2013                                                 } else {
2014                                                         $image = '';
2015                                                 }
2016                                                 if ($image)     {
2017                                                         $fieldCode=sprintf('<input type="image" name="%s"%s src="%s"%s />',
2018                                                                 $confData['fieldname'], $elementIdAttribute, $image, $params);
2019                                                 } else  {
2020                                                         $fieldCode=sprintf('<input type="submit" name="%s"%s value="%s"%s />',
2021                                                                 $confData['fieldname'], $elementIdAttribute, t3lib_div::deHSCentities(htmlspecialchars($value)), $addParams);
2022                                                 }
2023                                         break;
2024                                         case 'reset':
2025                                                 $value=trim($parts[2]);
2026                                                 $fieldCode=sprintf('<input type="reset" name="%s"%s value="%s"%s />',
2027                                                         $confData['fieldname'], $elementIdAttribute, t3lib_div::deHSCentities(htmlspecialchars($value)), $addParams);
2028                                         break;
2029                                         case 'label':
2030                                                 $fieldCode = nl2br(htmlspecialchars(trim($parts[2])));
2031                                         break;
2032                                         default:
2033                                                 $confData['type'] = 'comment';
2034                                                 $fieldCode = trim($parts[2]).'&nbsp;';
2035                                         break;
2036                                 }
2037                                 if ($fieldCode) {
2038
2039                                                 // Checking for special evaluation modes:
2040                                         if (t3lib_div::inList('textarea,input,password',$confData['type']) && strlen(trim($parts[3])))  {
2041                                                 $modeParameters = t3lib_div::trimExplode(':',$parts[3]);
2042                                         } else {
2043                                                 $modeParameters = array();
2044                                         }
2045
2046                                                 // Adding evaluation based on settings:
2047                                         switch ((string)$modeParameters[0])     {
2048                                                 case 'EREG':
2049                                                         $fieldlist[] = '_EREG';
2050                                                         $fieldlist[] = rawurlencode($modeParameters[1]);
2051                                                         $fieldlist[] = rawurlencode($modeParameters[2]);
2052                                                         $fieldlist[] = rawurlencode($confData['fieldname']);
2053                                                         $fieldlist[] = rawurlencode($confData['label']);
2054                                                         $confData['required'] = 1;      // Setting this so "required" layout is used.
2055                                                 break;
2056                                                 case 'EMAIL':
2057                                                         $fieldlist[] = '_EMAIL';
2058                                                         $fieldlist[] = rawurlencode($confData['fieldname']);
2059                                                         $fieldlist[] = rawurlencode($confData['label']);
2060                                                         $confData['required'] = 1;      // Setting this so "required" layout is used.
2061                                                 break;
2062                                                 default:
2063                                                         if ($confData['required'])      {
2064                                                                 $fieldlist[] = rawurlencode($confData['fieldname']);
2065                                                                 $fieldlist[] = rawurlencode($confData['label']);
2066                                                         }
2067                                                 break;
2068                                         }
2069
2070                                                 // Field:
2071                                         $fieldLabel = $confData['label'];
2072                                         if ($conf['accessibility'] && trim($fieldLabel) && !preg_match('/^(label|hidden|comment)$/',$confData['type'])) {
2073                                                 $fieldLabel = '<label for="'.$prefix.$fName.'">'.$fieldLabel.'</label>';
2074                                         }
2075
2076                                                 // Getting template code:
2077                                         $fieldCode = $this->stdWrap($fieldCode, $conf['fieldWrap.']);
2078                                         $labelCode = $this->stdWrap($fieldLabel, $conf['labelWrap.']);
2079                                         $commentCode = $this->stdWrap($confData['label'], $conf['commentWrap.']); // RTF
2080                                         $result = $conf['layout'];
2081                                         if ($conf['REQ'] && $confData['required'])      {
2082                                                 if (is_array($conf['REQ.']['fieldWrap.']))
2083                                                         $fieldCode = $this->stdWrap($fieldCode, $conf['REQ.']['fieldWrap.']);
2084                                                 if (is_array($conf['REQ.']['labelWrap.']))
2085                                                         $labelCode = $this->stdWrap($fieldLabel, $conf['REQ.']['labelWrap.']);
2086                                                 if ($conf['REQ.']['layout'])    {
2087                                                         $result = $conf['REQ.']['layout'];
2088                                                 }
2089                                         }
2090                                         if ($confData['type']=='comment' && $conf['COMMENT.']['layout'])        {
2091                                                 $result = $conf['COMMENT.']['layout'];
2092                                         }
2093                                         if ($confData['type']=='check' && $conf['CHECK.']['layout'])    {
2094                                                 $result = $conf['CHECK.']['layout'];
2095                                         }
2096                                         if ($confData['type']=='radio' && $conf['RADIO.']['layout'])    {
2097                                                 $result = $conf['RADIO.']['layout'];
2098                                         }
2099                                         if ($confData['type']=='label' && $conf['LABEL.']['layout']) {
2100                                                 $result = $conf['LABEL.']['layout'];
2101                                         }
2102                                         $result = str_replace('###FIELD###',$fieldCode,$result);
2103                                         $result = str_replace('###LABEL###',$labelCode,$result);
2104                                         $result = str_replace('###COMMENT###',$commentCode,$result); //RTF
2105                                         $content.= $result;
2106                                 }
2107                         }
2108                 }
2109                 if ($conf['stdWrap.'])  { $content = $this->stdWrap($content, $conf['stdWrap.']); }
2110
2111
2112                         // redirect (external: where to go afterwards. internal: where to submit to)
2113                 $theRedirect = $this->stdWrap($conf['redirect'], $conf['redirect.']);                   // redirect should be set to the page to redirect to after an external script has been used. If internal scripts is used, and if no 'type' is set that dictates otherwise, redirect is used as the url to jump to as long as it's an integer (page)
2114                 $page = $GLOBALS['TSFE']->page;
2115                 if (!$theRedirect)      {               // Internal: Just submit to current page
2116                         $LD = $GLOBALS['TSFE']->tmpl->linkData($page, $conf['target'], $conf['no_cache'],'index.php', '', $this->getClosestMPvalueForPage($page['uid']));
2117                 } elseif (t3lib_div::testInt($theRedirect))     {               // Internal: Submit to page with ID $theRedirect
2118                         $page = $GLOBALS['TSFE']->sys_page->getPage_noCheck($theRedirect);
2119                         $LD = $GLOBALS['TSFE']->tmpl->linkData($page, $conf['target'], $conf['no_cache'],'index.php', '', $this->getClosestMPvalueForPage($page['uid']));
2120                 } else {        // External URL, redirect-hidden field is rendered!
2121                         $LD = $GLOBALS['TSFE']->tmpl->linkData($page, $conf['target'], $conf['no_cache'],'', '', $this->getClosestMPvalueForPage($page['uid']));
2122                         $LD['totalURL'] = $theRedirect;
2123                         $hiddenfields.= '<input type="hidden" name="redirect" value="'.htmlspecialchars($LD['totalURL']).'" />';                // 18-09-00 added
2124                 }
2125
2126                         // Formtype (where to submit to!):
2127                 $formtype = $propertyOverride['type'] ? $propertyOverride['type'] : $this->stdWrap($conf['type'], $conf['type.']);
2128                 if (t3lib_div::testInt($formtype))      {       // Submit to a specific page
2129                         $page = $GLOBALS['TSFE']->sys_page->getPage_noCheck($formtype);
2130                         $LD_A = $GLOBALS['TSFE']->tmpl->linkData($page, $conf['target'], $conf['no_cache'], '', '', $this->getClosestMPvalueForPage($page['uid']));
2131                         $action = $LD_A['totalURL'];
2132                 } elseif ($formtype)    {       // Submit to external script
2133                         $LD_A = $LD;
2134                         $action = $formtype;
2135                 } elseif (t3lib_div::testInt($theRedirect))     {
2136                         $LD_A = $LD;
2137                         $action = $LD_A['totalURL'];
2138                 } else {                // Submit to "nothing" - which is current page
2139                         $LD_A = $GLOBALS['TSFE']->tmpl->linkData($GLOBALS['TSFE']->page, $conf['target'], $conf['no_cache'], '', '', $this->getClosestMPvalueForPage($page['uid']));
2140                         $action = $LD_A['totalURL'];
2141                 }
2142
2143                         // Recipient:
2144                 $theEmail = $this->stdWrap($conf['recipient'], $conf['recipient.']);
2145                 if ($theEmail && !$GLOBALS['TYPO3_CONF_VARS']['FE']['secureFormmail'])  {
2146                         $theEmail = $GLOBALS['TSFE']->codeString($theEmail);
2147                         $hiddenfields.= '<input type="hidden" name="recipient" value="'.htmlspecialchars($theEmail).'" />';
2148                 }
2149
2150                         // location data:
2151                 if ($conf['locationData'])      {
2152                         if ($conf['locationData']=='HTTP_POST_VARS' && isset($_POST['locationData']))   {
2153                                 $locationData = t3lib_div::_POST('locationData');
2154                         } else {
2155                                 $locationData = $GLOBALS['TSFE']->id.':'.$this->currentRecord;  // locationData is [hte page id]:[tablename]:[uid of record]. Indicates on which page the record (from tablename with uid) is shown. Used to check access.
2156                         }
2157                         $hiddenfields.='<input type="hidden" name="locationData" value="'.htmlspecialchars($locationData).'" />';
2158                 }
2159
2160                         // hidden fields:
2161                 if (is_array($conf['hiddenFields.']))   {
2162                         reset($conf['hiddenFields.']);
2163                         while (list($hF_key,$hF_conf) = each($conf['hiddenFields.']))   {
2164                                 if (substr($hF_key,-1)!='.')    {
2165                                         $hF_value = $this->cObjGetSingle($hF_conf,$conf['hiddenFields.'][$hF_key.'.'],'hiddenfields');
2166                                         if (strlen($hF_value) && t3lib_div::inList('recipient_copy,recipient',$hF_key)) {
2167                                                 if ($GLOBALS['TYPO3_CONF_VARS']['FE']['secureFormmail'])        {
2168                                                         continue;
2169                                                 }
2170                                                 $hF_value = $GLOBALS['TSFE']->codeString($hF_value);
2171                                         }
2172                                         $hiddenfields.= '<input type="hidden" name="'.$hF_key.'" value="'.htmlspecialchars($hF_value).'" />';
2173                                 }
2174                         }
2175                 }
2176
2177                         // Wrap all hidden fields in a div tag (see http://bugs.typo3.org/view.php?id=678)
2178                 $hiddenfields = '<div style="display:none;">'.$hiddenfields.'</div>';
2179
2180                 if ($conf['REQ'])       {
2181                         $validateForm=' onsubmit="return validateForm(\''.$formname.'\',\''.implode(',',$fieldlist).'\','.t3lib_div::quoteJSvalue($conf['goodMess']).','.t3lib_div::quoteJSvalue($conf['badMess']).','.t3lib_div::quoteJSvalue($conf['emailMess']).')"';
2182                         $GLOBALS['TSFE']->additionalHeaderData['JSFormValidate'] = '<script type="text/javascript" src="'.$GLOBALS['TSFE']->absRefPrefix.'t3lib/jsfunc.validateform.js"></script>';
2183                 } else $validateForm='';
2184
2185                         // Create form tag:
2186                 $theTarget = ($theRedirect?$LD['target']:$LD_A['target']);
2187                 $content = array(
2188                         '<form'.
2189                                 ' action="'.htmlspecialchars($action).'"'.
2190                                 ' id="'.$formname.'"'.($xhtmlStrict ? '' : ' name="'.$formname.'"').
2191                                 ' enctype="'.$GLOBALS['TYPO3_CONF_VARS']['SYS']['form_enctype'].'"'.
2192                                 ' method="'.($conf['method']?$conf['method']:'post').'"'.
2193                                 ($theTarget ? ' target="'.$theTarget.'"' : '').
2194                                 $validateForm.
2195                                 '>',
2196                         $hiddenfields.$content,
2197                         '</form>'
2198                 );
2199
2200                 if ($conf['arrayReturnMode'])   {
2201                         $content['validateForm']=$validateForm;
2202                         $content['formname']=$formname;
2203                         return $content;
2204                 } else {
2205                         return implode('',$content);
2206                 }
2207         }
2208
2209         /**
2210          * Rendering the cObject, SEARCHRESULT
2211          *
2212          * @param       array           Array of TypoScript properties
2213          * @return      string          Output
2214          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=368&cHash=d00731cd7b
2215          */
2216         function SEARCHRESULT($conf)    {
2217                 if (t3lib_div::_GP('sword') && t3lib_div::_GP('scols')) {
2218                         $search = t3lib_div::makeInstance('tslib_search');
2219                         $search->register_and_explode_search_string(t3lib_div::_GP('sword'));
2220                         $search->register_tables_and_columns(t3lib_div::_GP('scols'),$conf['allowedCols']);
2221                                 // depth
2222                         $depth=100;
2223                                 // the startId is found
2224                         $theStartId=0;
2225                         if (t3lib_div::testInt(t3lib_div::_GP('stype')))        {
2226                                 $temp_theStartId=t3lib_div::_GP('stype');
2227                                 $rootLine = $GLOBALS['TSFE']->sys_page->getRootLine($temp_theStartId);
2228                                         // The page MUST have a rootline with the Level0-page of the current site inside!!
2229                                 while(list(,$val)=each($rootLine))      {
2230                                         if($val['uid']==$GLOBALS['TSFE']->tmpl->rootLine[0]['uid'])     {
2231                                                 $theStartId=$temp_theStartId;
2232                                         }
2233                                 }
2234                         } else if (t3lib_div::_GP('stype'))     {
2235                                 if (substr(t3lib_div::_GP('stype'),0,1)=='L')   {
2236                                         $pointer = intval(substr(t3lib_div::_GP('stype'),1));
2237                                         $theRootLine = $GLOBALS['TSFE']->tmpl->rootLine;
2238                                                 // location Data:
2239                                         $locDat_arr = explode(':',t3lib_div::_POST('locationData'));
2240                                         $pId = intval($locDat_arr[0]);
2241                                         if ($pId)       {
2242                                                 $altRootLine = $GLOBALS['TSFE']->sys_page->getRootLine($pId);
2243                                                 ksort($altRootLine);
2244                                                 if (count($altRootLine))        {
2245                                                                 // check if the rootline has the real Level0 in it!!
2246                                                         reset($altRootLine);
2247                                                         $hitRoot=0;
2248                                                         $theNewRoot=array();
2249                                                         while(list(,$val)=each($altRootLine))   {
2250                                                                 if($hitRoot || $val['uid']==$GLOBALS['TSFE']->tmpl->rootLine[0]['uid']) {
2251                                                                         $hitRoot=1;
2252                                                                         $theNewRoot[]=$val;
2253                                                                 }
2254                                                         }
2255                                                         if ($hitRoot)   {
2256                                                                 $theRootLine = $theNewRoot;             // Override the real rootline if any thing
2257                                                         }
2258                                                 }
2259                                         }
2260                                         $key = $this->getKey($pointer,$theRootLine);
2261                                         $theStartId = $theRootLine[$key]['uid'];
2262                                 }
2263                         }
2264                         if (!$theStartId)       {
2265                                         // If not set, we use current page
2266                                 $theStartId = $GLOBALS['TSFE']->id;
2267                         }
2268                                 // generate page-tree
2269                         $search->pageIdList.= $this->getTreeList(-1*$theStartId,$depth);
2270
2271                         $endClause = 'pages.uid IN ('.$search->pageIdList.')
2272                                 AND pages.doktype in ('.$GLOBALS['TYPO3_CONF_VARS']['FE']['content_doktypes'].($conf['addExtUrlsAndShortCuts']?',3,4':'').')
2273                                 AND pages.no_search=0'.
2274                                 $this->enableFields($search->fTable).
2275                                 $this->enableFields('pages');
2276
2277                         if ($conf['languageField.'][$search->fTable])   {
2278                                 $endClause.= ' AND '.$search->fTable.'.'.$conf['languageField.'][$search->fTable].' = '.intval($GLOBALS['TSFE']->sys_language_uid);     // (using sys_language_uid which is the ACTUAL language of the page. sys_language_content is only for selecting DISPLAY content!)
2279                         }
2280
2281                                 // build query
2282                         $search->build_search_query($endClause);
2283
2284                                 // count...
2285                         if (t3lib_div::testInt(t3lib_div::_GP('scount')))       {
2286                                 $search->res_count = t3lib_div::_GP('scount');
2287                         } else {
2288                                 $search->count_query();
2289                         }
2290
2291                                 // range
2292                         $spointer = intval(t3lib_div::_GP('spointer'));
2293                         if (isset($conf['range']))      {
2294                                 $theRange = intval($conf['range']);
2295                         } else {
2296                                 $theRange = 20;
2297                         }
2298
2299                                 // Order By:
2300                         if (!$conf['noOrderBy'])        {
2301                                 $search->queryParts['ORDERBY'] = 'pages.lastUpdated, pages.tstamp';
2302                         }
2303
2304                         $search->queryParts['LIMIT'] = $spointer.','.$theRange;
2305
2306                                 // search...
2307                         $search->execute_query();
2308                         if ($GLOBALS['TYPO3_DB']->sql_num_rows($search->result))        {
2309                                 $GLOBALS['TSFE']->register['SWORD_PARAMS'] = $search->get_searchwords();
2310
2311                                 $total = $search->res_count;
2312                                 $rangeLow = t3lib_div::intInRange($spointer+1,1,$total);
2313                                 $rangeHigh = t3lib_div::intInRange($spointer+$theRange,1,$total);
2314                                         // prev/next url:
2315                                 $LD = $GLOBALS['TSFE']->tmpl->linkData($GLOBALS['TSFE']->page,$conf['target'],1,'', '', $this->getClosestMPvalueForPage($GLOBALS['TSFE']->page['uid']));
2316                                 $targetPart = $LD['target'] ? ' target="'.htmlspecialchars($LD['target']).'"' : '';
2317                                 $urlParams = $this->URLqMark($LD['totalURL'],
2318                                                 '&sword='.rawurlencode(t3lib_div::_GP('sword')).
2319                                                 '&scols='.rawurlencode(t3lib_div::_GP('scols')).
2320                                                 '&stype='.rawurlencode(t3lib_div::_GP('stype')).
2321                                                 '&scount='.$total);
2322                                         // substitution:
2323                                 $result= $this->cObjGetSingle($conf['layout'],$conf['layout.'], 'layout');
2324                                 $result = str_replace('###RANGELOW###',$rangeLow,$result);
2325                                 $result = str_replace('###RANGEHIGH###',$rangeHigh,$result);
2326                                 $result = str_replace('###TOTAL###',$total,$result);
2327
2328                                 if ($rangeHigh<$total)  {
2329                                         $next = $this->cObjGetSingle($conf['next'], $conf['next.'], 'next');
2330                                         $next = '<a href="'.htmlspecialchars($urlParams.'&spointer='.($spointer+$theRange)).'"'.$targetPart.$GLOBALS['TSFE']->ATagParams.'>'.$next.'</a>';
2331                                 } else $next='';
2332                                 $result = str_replace('###NEXT###',$next,$result);
2333
2334                                 if ($rangeLow>1)        {
2335                                         $prev = $this->cObjGetSingle($conf['prev'], $conf['prev.'], 'prev');
2336                                         $prev = '<a href="'.htmlspecialchars($urlParams.'&spointer='.($spointer-$theRange)).'"'.$targetPart.$GLOBALS['TSFE']->ATagParams.'>'.$prev.'</a>';
2337                                 } else $prev='';
2338                                 $result = str_replace('###PREV###',$prev,$result);
2339
2340                                         // searching result
2341                                 $theValue = $this->cObjGetSingle($conf['resultObj'], $conf['resultObj.'],'resultObj');
2342                                 $cObj = t3lib_div::makeInstance('tslib_cObj');
2343                                 $cObj->setParent($this->data,$this->currentRecord);
2344                                 $renderCode='';
2345                                 while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($search->result))   {
2346                                                 // versionOL() here? This is search result displays, is that possible to preview anyway? Or are records selected here already future versions?
2347                                         $cObj->start($row);
2348                                         $renderCode.=$cObj->cObjGetSingle($conf['renderObj'], $conf['renderObj.'],'renderObj');
2349                                 }
2350                                 $theValue.=$this->wrap($renderCode,$conf['renderWrap']);
2351                                 $theValue = str_replace('###RESULT###',$theValue,$result);
2352                         } else {
2353                                 $theValue = $this->cObjGetSingle($conf['noResultObj'], $conf['noResultObj.'],'noResultObj');
2354                         }
2355
2356                         $GLOBALS['TT']->setTSlogMessage('Search in fields:   '.$search->listOfSearchFields);
2357
2358                                 // wrapping
2359                         $content=$theValue;
2360                         if ($conf['wrap']) {
2361                                 $content=$this->wrap($content, $conf['wrap']);
2362                         }
2363                         if ($conf['stdWrap.']) {
2364                                 $content=$this->stdWrap($content, $conf['stdWrap.']);
2365                         }
2366                                 // returning
2367                         $GLOBALS['TSFE']->set_no_cache();
2368                         return $content;
2369                 }
2370         }
2371
2372         /**
2373          * Rendering the cObject, PHP_SCRIPT, PHP_SCRIPT_INT and PHP_SCRIPT_EXT
2374          *
2375          * @param       array           Array of TypoScript properties
2376          * @param       string          If "INT", then rendering "PHP_SCRIPT_INT"; If "EXT", then rendering "PHP_SCRIPT_EXT"; Default is rendering "PHP_SCRIPT" (cached)
2377          * @return      string          Output
2378          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=370&cHash=aa107f2ad8
2379          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=371&cHash=53f71d025e
2380          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=372&cHash=91fe391e1c
2381          */
2382         function PHP_SCRIPT($conf,$ext='')      {
2383                 $incFile = $GLOBALS['TSFE']->tmpl->getFileName($conf['file']);
2384                 $content='';
2385                 if ($incFile && $GLOBALS['TSFE']->checkFileInclude($incFile))   {
2386                         switch($ext)    {
2387                                 case 'INT':
2388                                 case 'EXT':
2389                                         $substKey = $ext.'_SCRIPT.'.$GLOBALS['TSFE']->uniqueHash();
2390                                         $content.='<!--'.$substKey.'-->';
2391                                         $GLOBALS['TSFE']->config[$ext.'incScript'][$substKey] = array(
2392                                                 'file'=>$incFile,
2393                                                 'conf'=>$conf,
2394                                                 'type'=>'SCRIPT'
2395                                         );
2396                                         if ($ext=='INT')        {
2397                                                 $GLOBALS['TSFE']->config[$ext.'incScript'][$substKey]['cObj'] = serialize($this);
2398                                         } else {
2399                                                 $GLOBALS['TSFE']->config[$ext.'incScript'][$substKey]['data'] = $this->data;
2400                                         }
2401                                 break;
2402                                 default:
2403                                                 // Added 31-12-00: Make backup...
2404                                         $this->oldData = $this->data;
2405                                                 // Include file..
2406                                         include('./'.$incFile);
2407                                                 // Added 31-12-00: restore...
2408                                         if ($RESTORE_OLD_DATA)  {
2409                                                 $this->data = $this->oldData;
2410                                         }
2411                                 break;
2412                         }
2413                 }
2414                 return $content;
2415         }
2416
2417         /**
2418          * Rendering the cObject, TEMPLATE
2419          *
2420          * @param       array           Array of TypoScript properties
2421          * @return      string          Output
2422          * @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=373&cHash=109a171b1e
2423          * @see substituteMarkerArrayCached()
2424          */
2425         function TEMPLATE($conf)        {
2426                 $subparts = Array();
2427                 $marks = Array();
2428                 $wraps = Array();
2429                 $content='';
2430
2431                 list($PRE,$POST) = explode('|',$conf['markerWrap'] ? $conf['markerWrap'] : '### | ###');
2432                 $POST = trim($POST);
2433                 $PRE  = trim($PRE);
2434
2435                         // Getting the content
2436                 $content = $this->cObjGetSingle($conf['template'],$conf['template.'],'template');
2437                 if ($conf['workOnSubpart'])     {
2438                         $content = $this->getSubpart($content, $PRE.$conf['workOnSubpart'].$POST);
2439                 }
2440
2441                         // Fixing all relative paths found:
2442                 if ($conf['relPathPrefix'])     {
2443                         $htmlParser = t3lib_div::makeInstance('t3lib_parsehtml');
2444                         $content = $htmlParser->prefixResourcePath($conf['relPathPrefix'],$content,$conf['relPathPrefix.']);
2445                 }
2446
2447                 if ($content)   {
2448                         if ($conf['nonCachedSubst'])    {               // NON-CACHED:
2449                                         // Getting marks
2450                                 if (is_array($conf['marks.']))  {
2451                                         reset($conf['marks.']);
2452                                         while(list($theKey,$theValue)=each($conf['marks.']))    {
2453                                                 if (!strstr($theKey,'.'))       {
2454                                                         $content = str_replace(
2455                                                                 $PRE.$theKey.$POST,
2456                                                                 $this->cObjGetSingle($theValue,$conf['marks.'][$theKey.'.'],'marks.'.$theKey),
2457                                                                 $content);
2458                                                 }
2459                                         }
2460                                 }
2461
2462                                         // Getting subparts.
2463                                 if (is_array($conf['subparts.']))       {
2464                                         reset($conf['subparts.']);
2465                                         while(list($theKey,$theValue)=each($conf['subparts.'])) {
2466                                                 if (!strstr($theKey,'.'))       {
2467                                                         $subpart = $this->getSubpart($content, $PRE.$theKey.$POST);
2468                                                         if ($subpart)   {
2469                                                                 $this->setCurrentVal($subpart);
2470                                                                 $content = $this->substituteSubpart(
2471                                                                         $content,
2472                                                                         $PRE.$theKey.$POST,
2473                                                                         $this->cObjGetSingle($theValue,$conf['subparts.'][$theKey.'.'],'subparts.'.$theKey),
2474                                                                         1
2475                                                                 );
2476                                                         }
2477                                                 }
2478                                         }
2479                                 }
2480                                         // Getting subpart wraps
2481                                 if (is_array($conf['wraps.']))  {
2482                                         reset($conf['wraps.']);
2483                                         while(list($theKey,$theValue)=each($conf['wraps.']))    {
2484                                                 if (!strstr($theKey,'.'))       {
2485                                                         $subpart = $this->getSubpart($content, $PRE.$theKey.$POST);
2486                                                         if ($subpart)   {
2487                                                                 $this->setCurrentVal($subpart);
2488                                                                 $content = $this->substituteSubpart(
2489                                                                         $content,
2490                                                                         $PRE.$theKey.$POST,
2491                                                                         explode('|',$this->cObjGetSingle($theValue,$conf['wraps.'][$theKey.'.'],'wraps.'.$theKey)),
2492                                                                         1
2493                                                                 );
2494                                                         }
2495                                                 }
2496                                         }
2497                                 }
2498                         } else {        // CACHED
2499                                         // Getting subparts.
2500                                 if (is_array($conf['subparts.']))       {
2501                                         reset($conf['subparts.']);
2502                                         while(list($theKey,$theValue)=each($conf['subparts.'])) {
2503                                                 if (!strstr($theKey,'.'))       {
2504                                                         $subpart = $this->getSubpart($content, $PRE.$theKey.$POST);
2505                                                         if ($subpart)   {
2506                                                                 $GLOBALS['TSFE']->register['SUBPART_'.$theKey] = $subpart;
2507                                                                 $subparts[$theKey]['name'] = $theValue;
2508                                                                 $subparts[$theKey]['conf'] = $conf['subparts.'][$theKey.'.'];
2509                                                         }
2510                                                 }
2511                                         }
2512                                 }
2513                                         // Getting marks
2514                                 if (is_array($conf['marks.']))  {
2515                                         reset($conf['marks.']);
2516                                         while(list($theKey,$theValue)=each($conf['marks.']))    {
2517                                                 if (!strstr($theKey,'.'))       {
2518                                                         $marks[$theKey]['name'] = $theValue;
2519                                                         $marks[$theKey]['conf'] = $conf['marks.'][$theKey.'.'];
2520                                                 }
2521                                         }
2522                                 }
2523                                         // Getting subpart wraps
2524                                 if (is_array($conf['wraps.']))  {
2525                                         reset($conf['wraps.']);
2526                                         while(list($theKey,$theValue)=each($conf['wraps.']))    {
2527                                                 if (!strstr($theKey,'.'))       {
2528                                                         $wraps[$theKey]['name'] = $theValue;
2529                                                         $wraps[$theKey]['conf'] = $conf['wraps.'][$theKey.'.'];
2530                                                 }
2531                                         }
2532                                 }
2533                                         // Getting subparts
2534