"TYPO3 4.0.1: typo3_src-4.0.1/t3lib/class.t3lib_tstemplate.php Source File", "datetime" => "Sat Dec 2 19:22:20 2006", "date" => "2 Dec 2006", "doxygenversion" => "1.4.6", "projectname" => "TYPO3 4.0.1", "projectnumber" => "4.0.1" ); get_header($doxygen_vars); ?>

class.t3lib_tstemplate.php

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
















class t3lib_TStemplate  {

                // Debugging, analysis:
        var $tt_track = 1;                                      // If set, the global tt-timeobject is used to log the performance.
        var $forceTemplateParsing=0;            // If set, the template is always rendered. Used from Admin Panel.

                // Backend Analysis modules settings:
        var $matchAlternative=array();          // This array is passed on to matchObj by generateConfig(). If it holds elements, they are used for matching instead. See commment at the match-class. Used for backend modules only. Never frontend!
        var $matchAll=0;                                        // If set, the match-class matches everything! Used for backend modules only. Never frontend!
        var $parseEditorCfgField=0;                     // If set, the Backend Editor Configuration TypoScript is also parsed (this is not needed for the frontend)
        var $backend_info = 0;
        var $getFileName_backPath='';           // Set from the backend - used to set an absolute path (PATH_site) so that relative resources are properly found with getFileName()

                // Externally set breakpoints (used by Backend Modules)
        var $ext_constants_BRP=0;
        var $ext_config_BRP=0;
        var $ext_editorcfg_BRP=0;
        var $ext_regLinenumbers=FALSE;

                // Constants:
        var $uplPath = 'uploads/tf/';
        var $tempPath = 'typo3temp/';
        var $menuclasses = 'gmenu,tmenu,imgmenu,jsmenu';

                // Set Internally:
        var $whereClause = '';                          // This MUST be initialized by the init() function
        var $debug = 0;
        var $allowedPaths = array();            // This is the only paths (relative!!) that are allowed for resources in TypoScript. Should all be appended with '/'. You can extend these by the global array TYPO3_CONF_VARS. See init() function.
        var $currentPageData = '';                      // Contains "currentPageData" when rendered/fetched from cache. See getCurrentPageData()
        var $simulationHiddenOrTime=0;          // See init(); Set if preview of some kind is enabled.

        var $loaded = 0;                                        // Set, if the TypoScript template structure is loaded and OK, see ->start()
        var $setup = Array(                                     // Default TypoScript Setup code
                'styles.' => Array (
                        'insertContent' => 'CONTENT',
                        'insertContent.' => Array (
                                'table' => 'tt_content',
                                'select.' => Array (
                                        'orderBy' => 'sorting',
                                        'where' => 'colPos=0',
                                        'languageField' => 'sys_language_uid'
                                )
                        )
                ),
                'config.' => Array (
                        'extTarget' => '_top',
                        'stat' => 1,
                        'stat_typeNumList' => '0,1'
                )
        );
        var $flatSetup = Array (
        );
        var $const = Array (    // Default TypoScript Constants code:
                '_clear' => '<img src="clear.gif" width="1" height="1" alt="" />',
                '_blackBorderWrap' => '<table border="0" bgcolor="black" cellspacing="0" cellpadding="1"><tr><td> | </td></tr></table>',
                '_tableWrap' => '<table border="0" cellspacing="0" cellpadding="0"> | </table>',
                '_tableWrap_DEBUG' => '<table border="1" cellspacing="0" cellpadding="0"> | </table>',
                '_stdFrameParams' => 'frameborder="no" marginheight="0" marginwidth="0" noresize="noresize"',
                '_stdFramesetParams' => 'border="0" framespacing="0" frameborder="no"'
        );


                // For fetching TypoScript code from template hierarchy before parsing it. Each array contains code field values from template records/files:
        var $config = array();                          // Setup field
        var $constants = array();                       // Constant field
        var $editorcfg = array();                       // Backend Editor Configuration field

        var $hierarchyInfo = array();           // For Template Analyser in backend
        var $hierarchyInfoToRoot = array();             // For Template Analyser in backend (setup content only)
        var $nextLevel=0;                                       // Next-level flag (see runThroughTemplates())
        var $rootId;                                            // The Page UID of the root page
        var $rootLine;                                          // The rootline from current page to the root page
        var $absoluteRootLine;                          // Rootline all the way to the root. Set but runThroughTemplates
        var $outermostRootlineIndexWithTemplate=0;      // A pointer to the last entry in the rootline where a template was found.
        var $rowSum;                                            // Array of arrays with title/uid of templates in hierarchy
        var $resources='';                                      // Resources for the template hierarchy in a comma list
        var $sitetitle='';                                      // The current site title field.
        var $sections;                                          // Tracking all conditions found during parsing of TypoScript. Used for the "all" key in currentPageData
        var $sectionsMatch;                                     // Tracking all matching conditions found

                // Backend: ts_analyzer
        var $clearList_const=array();
        var $clearList_setup=array();
        var $clearList_editorcfg=array();
        var $parserErrors=array();
        var $setup_constants = array();

                // Other:
        var $fileCache = Array();                       // Used by getFileName for caching of references to file resources
        var $frames = Array();                          // Keys are frame names and values are type-values, which must be used to refer correctly to the content of the frames.
        var $MPmap = '';                                        // Contains mapping of Page id numbers to MP variables.




        function init() {
                        // $this->whereClause is used only to select templates from sys_template.
                        // $GLOBALS['SIM_EXEC_TIME'] is used so that we're able to simulate a later time as a test...
                $this->whereClause='AND deleted=0 ';
                if (!$GLOBALS['TSFE']->showHiddenRecords)       {
                        $this->whereClause.='AND hidden=0 ';
                }
                if ($GLOBALS['TSFE']->showHiddenRecords || $GLOBALS['SIM_EXEC_TIME']!=$GLOBALS['EXEC_TIME'])    {       // Set the simulation flag, if simulation is detected!
                        $this->simulationHiddenOrTime=1;
                }
                $this->whereClause.= 'AND (starttime<='.$GLOBALS['SIM_EXEC_TIME'].') AND (endtime=0 OR endtime>'.$GLOBALS['SIM_EXEC_TIME'].')';
                if (!$GLOBALS['TYPO3_CONF_VARS']['GFX']['gdlib'])       {
                        $this->menuclasses='tmenu,jsmenu,gmenu';
                }

                        // Sets the paths from where TypoScript resources are allowed to be used:
                $this->allowedPaths = Array ('media/','fileadmin/','uploads/','typo3temp/','t3lib/fonts/',TYPO3_mainDir.'ext/',TYPO3_mainDir.'sysext/','typo3conf/ext/');
                if ($GLOBALS['TYPO3_CONF_VARS']['FE']['addAllowedPaths'])       {
                        $pathArr = t3lib_div::trimExplode(',',$GLOBALS['TYPO3_CONF_VARS']['FE']['addAllowedPaths'],1);
                        while(list(,$p)=each($pathArr)) {
                                        // Once checked for path, but as this may run from typo3/mod/web/ts/ dir, that'll not work!! So the paths ar uncritically included here.
                                $this->allowedPaths[] = $p;
                        }
                }
        }

        function getCurrentPageData()   {
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('content', 'cache_pagesection', 'page_id='.intval($GLOBALS['TSFE']->id).' AND mpvar_hash='.t3lib_div::md5int($GLOBALS['TSFE']->MP));
                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                        $this->currentPageData = unserialize($row['content']);
                } else {
                        $this->currentPageData = 'none';
                }
                return $this->currentPageData;
        }

        function matching($cc)  {
                if (is_array($cc['all']))       {
                        reset($cc['all']);
                        $matchObj = t3lib_div::makeInstance('t3lib_matchCondition');
                        $matchObj->altRootLine=$cc['rootLine'];
                        while(list($key,$pre)=each($cc['all'])) {
                                if ($matchObj->match($pre))     {
                                        $sectionsMatch[$key]=$pre;
                                }
                        }
                        $cc['match']=$sectionsMatch;
                }
                return $cc;
        }

        function start($theRootLine)    {
                if (is_array($theRootLine))     {
                        $setupData='';
                        $cc=Array();
                        $hash='';
                        $this->runThroughTemplates($theRootLine);

                                // Getting the currentPageData if not already found
                        if (!$this->currentPageData)    {
                                $this->getCurrentPageData();
                        }

                                // This is about getting the hash string which is used to fetch the cached TypoScript template.
                                // If there was some cached currentPageData that's good (it gives us the hash),
                                // However if the actual rowSum and the rowSum of currentPageData is different from each other, thats a problem, and we should re-make the current page data.
                        if (is_array($this->currentPageData) &&
                                !strcmp(serialize($this->rowSum), serialize($this->currentPageData['rowSum']))  // The two ROWsums must NOT be different from each other - which they will be if start/endtime or hidden has changed!
                        )       {
                                        // If currentPageData was actually there, we match the result...
                                $cc['all'] = $this->currentPageData['all'];
                                $cc['rowSum'] = $this->currentPageData['rowSum'];
                                $cc = $this->matching($cc);
                                $hash = md5(serialize($cc));
                        } else {
                                        // If currentPageData was not there, we first find $rowSum (freshly generated). After that we try to see, if rowSum is stored with a list of all matching-parameters. If so we match the result
                                $rowSumHash = md5('ROWSUM:'.serialize($this->rowSum));
                                $result = t3lib_pageSelect::getHash($rowSumHash, 0);
                                if ($result)    {
                                        $cc['all'] = unserialize($result);
                                        $cc['rowSum'] = $this->rowSum;
                                        $cc = $this->matching($cc);
                                        $hash = md5(serialize($cc));
                                }
                        }

                        if ($hash)      {
                                        // Get TypoScript setup array
                                $setupData = t3lib_pageSelect::getHash($hash, 0);
                        }

                        if ($hash && $setupData && !$this->forceTemplateParsing)                {
                                        // If TypoScript setup structure was cached we unserialize it here:
                                $this->setup = unserialize($setupData);
                        } else {
                                        // Make configuration
                                $this->generateConfig();

                                        // This stores the template hash thing
                                $cc=Array();
                                $cc['all']=$this->sections;     // All sections in the template at this point is found
                                $cc['rowSum']=$this->rowSum;    // The line of templates is collected
                                $cc = $this->matching($cc);

                                $hash = md5(serialize($cc));

                                        // This stores the data.
                                t3lib_pageSelect::storeHash($hash, serialize($this->setup), 'TS TEMPLATE');

                                if ($this->tt_track)    $GLOBALS['TT']->setTSlogMessage('TS template size, serialized: '.strlen(serialize($this->setup)).' bytes');

                                $rowSumHash = md5('ROWSUM:'.serialize($this->rowSum));
                                t3lib_pageSelect::storeHash($rowSumHash, serialize($cc['all']), 'TMPL CONDITIONS - AL');
                        }
                                // Add rootLine
                        $cc['rootLine'] = $this->rootLine;
                                // Make global and save.
                        $GLOBALS['TSFE']->all=$cc;

                        if (!$this->simulationHiddenOrTime)     {       // Only save currentPageData, if we're not simulating by hidden/starttime/endtime
                                $insertFields = array(
                                        'page_id' => intval($GLOBALS['TSFE']->id),
                                        'mpvar_hash' => t3lib_div::md5int($GLOBALS['TSFE']->MP),
                                        'content' => serialize($cc),
                                        'tstamp' => $GLOBALS['EXEC_TIME']
                                );
                                $GLOBALS['TYPO3_DB']->exec_DELETEquery('cache_pagesection', 'page_id='.intval($GLOBALS['TSFE']->id).' AND mpvar_hash='.t3lib_div::md5int($GLOBALS['TSFE']->MP));

                                $GLOBALS['TYPO3_DB']->exec_INSERTquery('cache_pagesection', $insertFields);
                        }
                                // If everything OK.
                        if ($this->rootId && $this->rootLine && $this->setup)   {
                                $this->loaded = 1;
                        }
                }
        }















        /*******************************************************************
         *
         * Fetching TypoScript code text for the Template Hierarchy
         *
         *******************************************************************/

        function runThroughTemplates($theRootLine,$start_template_uid=0)        {
                $this->constants = Array();
                $this->config = Array();
                $this->editorcfg = Array();
                $this->rowSum = Array();
                $this->hierarchyInfoToRoot = Array();
                $this->absoluteRootLine=$theRootLine;   // Is the TOTAL rootline

                reset ($this->absoluteRootLine);
                $c=count($this->absoluteRootLine);
                for ($a=0;$a<$c;$a++)   {
                        if ($this->nextLevel)   {       // If some template loaded before has set a template-id for the next level, then load this template first!
                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_template', 'uid='.intval($this->nextLevel).' '.$this->whereClause);
                                $this->nextLevel = 0;
                                if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                                        $this->versionOL($row);
                                        if (is_array($row))     {
                                                $this->processTemplate($row,'sys_'.$row['uid'],$this->absoluteRootLine[$a]['uid'],'sys_'.$row['uid']);
                                                $this->outermostRootlineIndexWithTemplate=$a;
                                        }
                                }
                                $GLOBALS['TYPO3_DB']->sql_free_result($res);
                        }
                        $addC='';
                        if ($a==($c-1) && $start_template_uid)  {       // If first loop AND there is set an alternative template uid, use that
                                $addC=' AND uid='.intval($start_template_uid);
                        }

                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_template', 'pid='.intval($this->absoluteRootLine[$a]['uid']).$addC.' '.$this->whereClause,'','sorting',1);
                        if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                                $this->versionOL($row);
                                if (is_array($row))     {
                                        $this->processTemplate($row,'sys_'.$row['uid'],$this->absoluteRootLine[$a]['uid'],'sys_'.$row['uid']);
                                        $this->outermostRootlineIndexWithTemplate=$a;
                                }
                        }
                        $GLOBALS['TYPO3_DB']->sql_free_result($res);
                        $this->rootLine[] = $this->absoluteRootLine[$a];
                }
        }

        function processTemplate($row, $idList,$pid,$templateID='',$templateParent='')  {
                        // Adding basic template record information to rowSum array
                $this->rowSum[]=Array($row['uid'],$row['title'],$row['tstamp']);

                        // Processing "Clear"-flags
                if ($row['clear'])      {
                        $clConst = $row['clear']&1;
                        $clConf = $row['clear']&2;
                        if ($clConst)   {
                                $this->constants = Array();
                                $this->clearList_const=array();
                        }
                        if ($clConf)    {
                                $this->config = Array();
                                $this->hierarchyInfoToRoot = Array();
                                $this->clearList_setup=array();

                                $this->editorcfg = Array();
                                $this->clearList_editorcfg=array();
                        }
                }

                        // Include static records (static_template) or files (from extensions) (#1/2)
                if (!$row['includeStaticAfterBasedOn'])         {               // NORMAL inclusion, The EXACT same code is found below the basedOn inclusion!!!
                        $this->includeStaticTypoScriptSources($idList,$templateID,$pid,$row);
                }

                        // Include "Based On" sys_templates:
                if (trim($row['basedOn']))      {               // 'basedOn' is a list of templates to include
                                // Manually you can put this value in the field and then the based_on ID will be taken from the $_GET var defined by '=....'.
                                // Example: If $row['basedOn'] is 'EXTERNAL_BASED_ON_TEMPLATE_ID=based_on_uid', then the global var, based_on_uid - given by the URL like '&based_on_uid=999' - is included instead!
                                // This feature allows us a hack to test/demonstrate various included templates on the same set of content bearing pages. Used by the "freesite" extension.
                        $basedOn_hackFeature = explode('=',$row['basedOn']);
                        if ($basedOn_hackFeature[0]=='EXTERNAL_BASED_ON_TEMPLATE_ID' && $basedOn_hackFeature[1])                {
                                $id = intval(t3lib_div::_GET($basedOn_hackFeature[1]));
                                if ($id && !t3lib_div::inList($idList,'sys_'.$id))      {       // if $id is not allready included ...
                                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_template', 'uid='.$id.' '.$this->whereClause);
                                        if ($subrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {       // there was a template, then we fetch that
                                                $this->versionOL($subrow);
                                                if (is_array($subrow))  {
                                                        $this->processTemplate($subrow,$idList.',sys_'.$id,$pid, 'sys_'.$id,$templateID);
                                                }
                                        }
                                        $GLOBALS['TYPO3_DB']->sql_free_result($res);
                                }
                        } else {        // NORMAL OPERATION:
                                $basedOnArr = t3lib_div::intExplode(',',$row['basedOn']);
                                while(list(,$id)=each($basedOnArr))     {       // traversing list
                                        if (!t3lib_div::inList($idList,'sys_'.$id))     {       // if $id is not allready included ...
                                                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_template', 'uid='.intval($id).' '.$this->whereClause);
                                                if ($subrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {       // there was a template, then we fetch that
                                                        $this->versionOL($subrow);
                                                        if (is_array($subrow))  {
                                                                $this->processTemplate($subrow,$idList.',sys_'.$id,$pid, 'sys_'.$id,$templateID);
                                                        }
                                                }
                                                $GLOBALS['TYPO3_DB']->sql_free_result($res);
                                        }
                                }
                        }
                }

                        // Include static records (static_template) or files (from extensions) (#2/2)
                if ($row['includeStaticAfterBasedOn'])          {
                        $this->includeStaticTypoScriptSources($idList,$templateID,$pid,$row);
                }

                        // Creating hierarchy information; Used by backend analysis tools
                $this->hierarchyInfo[] = $this->hierarchyInfoToRoot[] = array(
                        'root'=>trim($row['root']),
                        'next'=>$row['nextLevel'],
                        'clConst'=>$clConst,
                        'clConf'=>$clConf,
                        'templateID'=>$templateID,
                        'templateParent'=>$templateParent,
                        'title'=>$row['title'],
                        'uid'=>$row['uid'],
                        'pid'=>$row['pid'],
                        'configLines' => substr_count($row['config'], chr(10))+1
                );

                        // Adding the content of the fields constants (Constants), config (Setup) and editorcfg (Backend Editor Configuration) to the internal arrays.
                $this->constants[] = $row['constants'];
                $this->config[] = $row['config'];
                if ($this->parseEditorCfgField)         $this->editorcfg[] = $row['editorcfg'];

                        // For backend analysis (Template Analyser) provide the order of added constants/config/editorcfg template IDs
                $this->clearList_const[]=$templateID;
                $this->clearList_setup[]=$templateID;
                if ($this->parseEditorCfgField)         $this->clearList_editorcfg[]=$templateID;

                        // Add resources and sitetitle if found:
                if (trim($row['resources']))    {
                        $this->resources = $row['resources'].','.$this->resources;
                }
                if (trim($row['sitetitle']))    {
                        $this->sitetitle = $row['sitetitle'];
                }
                        // If the template record is a Rootlevel record, set the flag and clear the template rootLine (so it starts over from this point)
                if (trim($row['root'])) {
                        $this->rootId = $pid;
                        $this->rootLine = Array();
                }
                        // If a template is set to be active on the next level set this internal value to point to this UID. (See runThroughTemplates())
                if ($row['nextLevel'])  {
                        $this->nextLevel = $row['nextLevel'];
                } else {
                        $this->nextLevel = 0;
                }
        }

        function includeStaticTypoScriptSources($idList,$templateID,$pid,$row)  {
                        // Static Template Records (static_template): include_static is a list of static templates to include
                if (trim($row['include_static']))       {
                        $include_staticArr = t3lib_div::intExplode(',',$row['include_static']);
                        reset($include_staticArr);
                        while(list(,$id)=each($include_staticArr))      {       // traversing list
                                if (!t3lib_div::inList($idList,'static_'.$id))  {       // if $id is not allready included ...
                                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'static_template', 'uid='.intval($id));
                                        if ($subrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {       // there was a template, then we fetch that
                                                $subrow = $this->prependStaticExtra($subrow);
                                                $this->processTemplate($subrow,$idList.',static_'.$id,$pid,'static_'.$id,$templateID);
                                        }
                                        $GLOBALS['TYPO3_DB']->sql_free_result($res);
                                }
                        }
                }

                        // Static Template Files (Text files from extensions): include_static_file is a list of static files to include (from extensions)
                if (trim($row['include_static_file']))  {
                        $include_static_fileArr = t3lib_div::trimExplode(',',$row['include_static_file'],1);
                        reset($include_static_fileArr);
                        while(list(,$ISF_file)=each($include_static_fileArr))   {       // traversing list
                                $ISF_file = trim($ISF_file);
                                if (substr($ISF_file,0,4)=='EXT:')      {
                                        list($ISF_extKey,$ISF_localPath) = explode('/',substr($ISF_file,4),2);
                                        if (strcmp($ISF_extKey,'') && t3lib_extMgm::isLoaded($ISF_extKey) && strcmp($ISF_localPath,'')) {
                                                $ISF_localPath = ereg_replace('\/$','',$ISF_localPath).'/';
                                                $ISF_filePath = t3lib_extMgm::extPath($ISF_extKey).$ISF_localPath;
                                                if (@is_dir($ISF_filePath))     {
                                                        $mExtKey = str_replace('_','',$ISF_extKey.'/'.$ISF_localPath);
                                                        $subrow=array(
                                                                'constants'=>   @is_file($ISF_filePath.'constants.txt') ?t3lib_div::getUrl($ISF_filePath.'constants.txt'):'',
                                                                'config'=>              @is_file($ISF_filePath.'setup.txt')             ?t3lib_div::getUrl($ISF_filePath.'setup.txt'):'',
                                                                'editorcfg'=>   @is_file($ISF_filePath.'editorcfg.txt') ?t3lib_div::getUrl($ISF_filePath.'editorcfg.txt'):'',
                                                                'include_static'=>      @is_file($ISF_filePath.'include_static.txt')?implode(',',array_unique(t3lib_div::intExplode(',',t3lib_div::getUrl($ISF_filePath.'include_static.txt')))):'',
                                                                'include_static_file'=> @is_file($ISF_filePath.'include_static_file.txt')?implode(',',array_unique(explode(',',t3lib_div::getUrl($ISF_filePath.'include_static_file.txt')))):'',
                                                                'title' =>              $ISF_file,
                                                                'uid' =>                $mExtKey
                                                        );
                                                        $subrow = $this->prependStaticExtra($subrow);

                                                        $this->processTemplate($subrow,$idList.',ext_'.$mExtKey,$pid, 'ext_'.$mExtKey,$templateID);
                                                }
                                        }
                                }
                        }
                }

                $this->addExtensionStatics($idList,$templateID,$pid,$row);
        }

        function addExtensionStatics($idList,$templateID,$pid,$row) {
                global $TYPO3_LOADED_EXT;

                if ($row['static_file_mode']==1 || ($row['static_file_mode']==0 && substr($templateID,0,4)=='sys_' && $row['root']))    {
                        reset($TYPO3_LOADED_EXT);
                        while(list($extKey,$files)=each($TYPO3_LOADED_EXT))     {
                                if (is_array($files) && ($files['ext_typoscript_constants.txt'] || $files['ext_typoscript_setup.txt'] || $files['ext_typoscript_editorcfg.txt']))       {
                                        $mExtKey = str_replace('_','',$extKey);
                                        $subrow=array(
                                                'constants'=>   $files['ext_typoscript_constants.txt']?t3lib_div::getUrl($files['ext_typoscript_constants.txt']):'',
                                                'config'=>              $files['ext_typoscript_setup.txt']?t3lib_div::getUrl($files['ext_typoscript_setup.txt']):'',
                                                'editorcfg'=>           $files['ext_typoscript_editorcfg.txt']?t3lib_div::getUrl($files['ext_typoscript_editorcfg.txt']):'',
                                                'title' =>              $extKey,
                                                'uid' =>                $mExtKey
                                        );
                                        $subrow = $this->prependStaticExtra($subrow);

                                        $this->processTemplate($subrow,$idList.',ext_'.$mExtKey,$pid, 'ext_'.$mExtKey,$templateID);
                                }
                        }
                }
        }

        function prependStaticExtra($subrow)    {
                $subrow['config'].=$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup.'][$subrow['uid']];
                $subrow['editorcfg'].=$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_editorcfg.'][$subrow['uid']];
                $subrow['constants'].=$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants.'][$subrow['uid']];
                return $subrow;
        }

        function versionOL(&$row)       {
                if (is_object($GLOBALS['TSFE']))        {       // Frontend:
                        $GLOBALS['TSFE']->sys_page->versionOL('sys_template',$row);
                } else {        // Backend:
                        t3lib_BEfunc::workspaceOL('sys_template',$row);
                }
        }

















        /*******************************************************************
         *
         * Parsing TypoScript code text from Template Records into PHP array
         *
         *******************************************************************/

        function generateConfig()       {
                        // Add default TS for all three code types:
                array_unshift($this->constants,''.$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants']);    // Adding default TS/constants
                array_unshift($this->config,''.$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup']);   // Adding default TS/setup
                array_unshift($this->editorcfg,''.$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_editorcfg']);    // Adding default TS/editorcfg

                        // Parse the TypoScript code text for include-instructions!
                $this->procesIncludes();

                        // These vars are also set lateron...
                $this->setup['resources']= $this->resources;
                $this->setup['sitetitle']= $this->sitetitle;



                // ****************************
                // Parse TypoScript Constants
                // ****************************

                        // Initialize parser and match-condition classes:
                $constants = t3lib_div::makeInstance('t3lib_TSparser');
                $constants->breakPointLN=intval($this->ext_constants_BRP);
                $constants->setup = $this->const;
                $constants->setup = $this->mergeConstantsFromPageTSconfig($constants->setup);
                $matchObj = t3lib_div::makeInstance('t3lib_matchCondition');
                $matchObj->matchAlternative = $this->matchAlternative;
                $matchObj->matchAll = $this->matchAll;          // Matches ALL conditions in TypoScript

                        // Traverse constants text fields and parse them
                foreach($this->constants as $str)       {
                        $constants->parse($str,$matchObj);
                }

                        // Read out parse errors if any
                $this->parserErrors['constants']=$constants->errors;

                        // Then flatten the structure from a multi-dim array to a single dim array with all constants listed as key/value pairs (ready for substitution)
                $this->flatSetup = Array();
                $this->flattenSetup($constants->setup,'','');



                // ***********************************************
                // Parse TypoScript Setup (here called "config")
                // ***********************************************
                        // Initialize parser and match-condition classes:
                $config = t3lib_div::makeInstance('t3lib_TSparser');
                $config->breakPointLN = intval($this->ext_config_BRP);
                $config->regLinenumbers = $this->ext_regLinenumbers;
                $config->setup = $this->setup;

                        // Transfer information about conditions found in "Constants" and which of them returned true.
                $config->sections = $constants->sections;
                $config->sectionsMatch = $constants->sectionsMatch;

                        // Traverse setup text fields and concatenate them into one, single string separated by a [GLOBAL] condition
                $all='';
                foreach($this->config as $str)  {
                        $all.="\n[GLOBAL]\n".$str;
                }

                        // Substitute constants in the Setup code:
                if ($this->tt_track)    $GLOBALS['TT']->push('Substitute Constants ('.count($this->flatSetup).')');
                $all = $this->substituteConstants($all);
                if ($this->tt_track)    $GLOBALS['TT']->pull();

                        // Searching for possible unsubstituted constants left (only for information)
                if (strstr($all,'{$'))  {
                        $findConst = explode('{$',$all);
                        $theConstList=Array();
                        next($findConst);
                        while(list(,$constVal)=each($findConst))        {
                                $constLen=t3lib_div::intInRange(strcspn($constVal,'}'),0,50);
                                $theConstList[]='{$'.substr($constVal,0,$constLen+1);
                        }
                        if ($this->tt_track)    $GLOBALS['TT']->setTSlogMessage(implode(',',$theConstList).': Constants may remain un-substituted!!',2);
                }

                        // Logging the textual size of the TypoScript Setup field text with all constants substituted:
                if ($this->tt_track)    $GLOBALS['TT']->setTSlogMessage('TypoScript template size as textfile: '.strlen($all).' bytes');

                        // Finally parse the Setup field TypoScript code (where constants are now substituted)
                $config->parse($all,$matchObj);

                        // Read out parse errors if any
                $this->parserErrors['config']=$config->errors;

                        // Transfer the TypoScript array from the parser object to the internal $this->setup array:
                $this->setup = $config->setup;
                if ($this->backend_info)        {
                        $this->setup_constants = $constants->setup;             // Used for backend purposes only
                }




                // **************************************************
                // Parse Backend Editor Configuration (backend only)
                // **************************************************
                if ($this->parseEditorCfgField) {
                        $editorcfg = t3lib_div::makeInstance('t3lib_TSparser');
                        $editorcfg->breakPointLN=intval($this->ext_editorcfg_BRP);
                        $editorcfg->setup = array();    // Empty as a start...

                        $all = implode("\n[GLOBAL]\n",$this->editorcfg);

                                // substitute constants in config
                        $all = $this->substituteConstants($all);

                                // parse Config
                        $matchObj->matchAll=1;  // This should make sure that conditions are disabled. For now they are NOT active for the backend.
                        $editorcfg->parse($all,$matchObj);
                        $this->parserErrors['editorcfg']=$editorcfg->errors;
                        $this->setup_editorcfg = $editorcfg->setup;
                }





                // ****************************************************************
                // Final processing of the $this->setup TypoScript Template array
                // Basically: This is unsetting/setting of certain reserved keys.
                // ****************************************************************

                        // These vars are allready set after 'processTemplate', but because $config->setup overrides them (in the line above!), we set them again. They are not changed compared to the value they had in the top of the page!
                unset($this->setup['resources']);
                unset($this->setup['resources.']);
                $this->setup['resources']= implode(',',t3lib_div::trimExplode(',',$this->resources,1));

                unset($this->setup['sitetitle']);
                unset($this->setup['sitetitle.']);
                $this->setup['sitetitle']= $this->sitetitle;

                        // Unsetting some vars...
                unset($this->setup['types.']);
                unset($this->setup['types']);
                if (is_array($this->setup)) {
                        reset ($this->setup);
                        while(list($theKey,)=each($this->setup))        {
                                if ($this->setup[$theKey]=='PAGE')      {
                                        $tN = $this->setup[$theKey.'.']['typeNum'];
                                        if (isset($tN)) {
                                                $this->setup['types.'][$tN] = $theKey;
                                        } elseif(!$this->setup['types.'][0])    {       // If there is no type 0 yet and typeNum was not set, we use the current object as the default
                                                $this->setup['types.'][0] = $theKey;
                                        }
                                }
                        }
                }
                unset($this->setup['styles.']);
                unset($this->setup['temp.']);
                unset($constants);

                        // Storing the conditions found/matched information:
                $this->sections = $config->sections;
                $this->sectionsMatch = $config->sectionsMatch;
        }

        function procesIncludes()       {
                reset($this->constants);
                while(list($k)=each($this->constants))  {
                        $this->constants[$k]=t3lib_TSparser::checkIncludeLines($this->constants[$k]);
                }

                reset($this->config);
                while(list($k)=each($this->config))     {
                        $this->config[$k]=t3lib_TSparser::checkIncludeLines($this->config[$k]);
                }

                reset($this->editorcfg);
                while(list($k)=each($this->editorcfg))  {
                        $this->editorcfg[$k]=t3lib_TSparser::checkIncludeLines($this->editorcfg[$k]);
                }
        }

        function mergeConstantsFromPageTSconfig($constArray)    {
                $TSdataArray = array();
                $TSdataArray[]=$GLOBALS['TYPO3_CONF_VARS']['BE']['defaultPageTSconfig'];        // Setting default configuration:

                for ($a=0;$a<=$this->outermostRootlineIndexWithTemplate;$a++)   {
                        $TSdataArray[]=$this->absoluteRootLine[$a]['TSconfig'];
                }
                        // Parsing the user TS (or getting from cache)
                $TSdataArray = t3lib_TSparser::checkIncludeLines_array($TSdataArray);
                $userTS = implode(chr(10).'[GLOBAL]'.chr(10),$TSdataArray);

                $parseObj = t3lib_div::makeInstance('t3lib_TSparser');
                $parseObj->parse($userTS);

                if (is_array($parseObj->setup['TSFE.']['constants.']))  {
                        $constArray = t3lib_div::array_merge_recursive_overrule($constArray,$parseObj->setup['TSFE.']['constants.']);
                }
                return $constArray;
        }

        function flattenSetup($setupArray, $prefix, $resourceFlag)      {
                if (is_array($setupArray))      {
                        reset($setupArray);
                        while(list($key,$val)=each($setupArray))        {
                                if ($prefix || substr($key,0,16)!='TSConstantEditor')   {               // We don't want 'TSConstantEditor' in the flattend setup on the first level (190201)
                                        if (is_array($val))     {
                                                $this->flattenSetup($val,$prefix.$key, ($key=='file.'));
                                        } elseif ($resourceFlag) {
                                                $this->flatSetup[$prefix.$key] = $this->getFileName($val);
                                        } else {
                                                $this->flatSetup[$prefix.$key] = $val;
                                        }
                                }
                        }
                }
        }

        function substituteConstants($all)      {
                if ($this->tt_track)    $GLOBALS['TT']->setTSlogMessage('Constants to substitute: '.count($this->flatSetup));

                $noChange = false;
                // recursive substitution of constants (up to 10 nested levels)
                for ($i = 0; $i < 10 && !$noChange; $i++) {
                        $old_all = $all;
                        $all = preg_replace_callback('/\{\$(.[^}]*)\}/', array($this, 'substituteConstantsCallBack'), $all);
                        if ($old_all == $all) {
                                $noChange = true;
                        }
                }

                return $all;
        }

        function substituteConstantsCallBack($matches) {
                // replace {$CONST} if found in $this->flatSetup, else leave unchanged
                return isset($this->flatSetup[$matches[1]]) && !is_array($this->flatSetup[$matches[1]]) ? $this->flatSetup[$matches[1]] : $matches[0];
        }










        /*******************************************************************
         *
         * Various API functions, used from elsewhere in the frontend classes
         *
         *******************************************************************/

        function splitConfArray($conf,$splitCount)      {

                        // Initialize variables:
                $splitCount = intval($splitCount);
                $conf2 = Array();

                if ($splitCount && is_array($conf))     {

                                // Initialize output to carry at least the keys:
                        for ($aKey=0;$aKey<$splitCount;$aKey++) {
                                $conf2[$aKey] = array();
                        }

                                // Recursive processing of array keys:
                        foreach($conf as $cKey => $val) {
                                if (is_array($val))     {
                                        $tempConf = $this->splitConfArray($val,$splitCount);
                                        foreach($tempConf as $aKey => $val)     {
                                                $conf2[$aKey][$cKey] = $val;
                                        }
                                }
                        }

                                // Splitting of all values on this level of the TypoScript object tree:
                        foreach($conf as $cKey => $val) {
                                if (!is_array($val))    {
                                        if (!strstr($val,'|*|') && !strstr($val,'||'))  {
                                                for ($aKey=0;$aKey<$splitCount;$aKey++) {
                                                        $conf2[$aKey][$cKey] = $val;
                                                }
                                        } else {
                                                $main = explode ('|*|',$val);
                                                $mainCount = count($main);

                                                $lastC = 0;
                                                $middleC = 0;
                                                $firstC = 0;

                                                if ($main[0])   {
                                                        $first = explode('||',$main[0]);
                                                        $firstC = count($first);
                                                }
                                                if ($main[1])   {
                                                        $middle = explode('||',$main[1]);
                                                        $middleC = count($middle);
                                                }
                                                if ($main[2])   {
                                                        $last = explode('||',$main[2]);
                                                        $lastC = count($last);
                                                        $value = $last[0];
                                                }

                                                for ($aKey=0;$aKey<$splitCount;$aKey++) {
                                                        if ($firstC && isset($first[$aKey])) {
                                                                $value = $first[$aKey];
                                                        } elseif ($middleC) {
                                                                $value = $middle[($aKey-$firstC)%$middleC];
                                                        }
                                                        if ($lastC && $lastC>=($splitCount-$aKey))      {
                                                                $value = $last[$lastC-($splitCount-$aKey)];
                                                        }
                                                        $conf2[$aKey][$cKey] = trim($value);
                                                }
                                        }
                                }
                        }
                }
                return $conf2;
        }

        function getFileName($fileFromSetup)    {
                $file = trim($fileFromSetup);
                if (!$file)     {
                        return;
                } elseif (strstr($file,'../'))  {
                        if ($this->tt_track)    $GLOBALS['TT']->setTSlogMessage('File path "'.$file.'" contained illegal string "../"!',3);
                        return;
                }
                        // cache
                $hash = md5($file);
                if (isset($this->fileCache[$hash]))     {
                        return $this->fileCache[$hash];
                }

                if (!strcmp(substr($file,0,4),'EXT:'))  {
                        $newFile='';
                        list($extKey,$script)=explode('/',substr($file,4),2);
                        if ($extKey && t3lib_extMgm::isLoaded($extKey)) {
                                $extPath=t3lib_extMgm::extPath($extKey);
                                $newFile=substr($extPath,strlen(PATH_site)).$script;
                        }
                        if (!@is_file(PATH_site.$newFile))      {
                                if ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('Extension media file "'.$newFile.'" was not found!',3);
                                return;
                        } else $file=$newFile;
                }

                        // find
                if (strstr($file,'/')) {        // here it is manual media
                        if(!strcmp(substr($file,0,6),'media/')) $file = 'typo3/sysext/cms/tslib/'.$file;
                        if (@is_file($this->getFileName_backPath.$file))        {
                                $outFile = $file;
                                $fileInfo = t3lib_div::split_fileref($outFile);
                                reset($this->allowedPaths);
                                $OK=0;
                                while(list(,$val)=each($this->allowedPaths))    {
                                        if (substr($fileInfo['path'],0,strlen($val))==$val){$OK=1; break;}
                                }
                                if ($OK)        {
                                        $this->fileCache[$hash]=$outFile;
                                        return $outFile;
                                } elseif ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('"'.$file.'" was not located in the allowed paths: ('.implode(',',$this->allowedPaths).')',3);
                        } elseif ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('"'.$this->getFileName_backPath.$file.'" is not a file (non-uploads/.. resource, did not exist).',3);
                } else {                // Here it is uploaded media:
                        $outFile = $this->extractFromResources($this->setup['resources'],$file);
                        if ($outFile)   {
                                if (@is_file($this->uplPath.$outFile))  {
                                        $this->fileCache[$hash] = $this->uplPath.$outFile;
                                        return $this->uplPath.$outFile;
                                } elseif ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('"'.$this->uplPath.$outFile.'" is not a file (did not exist).',3);
                        } elseif ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('"'.$file.'" is not a file (uploads/.. resource).',3);
                }
        }

        function extractFromResources($res,$file)       {
                if (t3lib_div::inList($res,$file))      {
                        $outFile = $file;
                } elseif (strstr($file,'*')) {
                        $fileparts=explode('*',$file);
                        $c=count($fileparts);
                        $files = explode(',',$res);
                        while(list(,$val)=each($files)) {
                                $test = trim($val);
                                if (ereg('^'.quotemeta($fileparts[0]).'.*'.quotemeta($fileparts[$c-1]).'$', $test))     {
                                        $outFile = $test;
                                        break;
                                }
                        }
                }
                return $outFile;
        }

        function checkFile($name,$menuArr)      {
                reset ($menuArr);
                while (list($aKey,)=each($menuArr))     {
                        $menuArr[$aKey][$name] = $this->getFileName($menuArr[$aKey][$name]);
                }
                return $menuArr;
        }

        function printTitle($title,$no_title=0,$titleFirst=0)   {
                $st = trim($this->setup['sitetitle']) ? $this->setup['sitetitle']:'';
                $title = $no_title ? '' : $title;
                if ($titleFirst)        {
                        $temp=$st;
                        $st=$title;
                        $title=$temp;
                }
                if ($title && $st)      {
                        return $st.': '.$title;
                } else {
                        return $st.$title;
                }
        }

        function fileContent($fName)    {
                $incFile = $this->getFileName($fName);
                if ($incFile && $fd=fopen($incFile,'rb'))       {
                        $content = '';
                        while (!feof($fd))      {
                                $content.=fread($fd, 5000);
                        }
                        fclose( $fd );
                        return $content;
                }
        }

        function wrap($content,$wrap)   {
                if ($wrap)      {
                        $wrapArr = explode('|', $wrap);
                        return trim($wrapArr[0]).$content.trim($wrapArr[1]);
                } else return $content;
        }

        function removeQueryString($url)        {
                if (substr($url,-1)=='?')       {
                        return substr($url,0,-1);
                } else {
                        return $url;
                }
        }

        function sortedKeyList($setupArr, $acceptOnlyProperties=FALSE)  {
                $keyArr = Array();

                reset($setupArr);
                while(list($key,)=each($setupArr))      {
                        $ikey = intval($key);
                        if (!strcmp($ikey,$key) || $acceptOnlyProperties)       {
                                $keyArr[] = $ikey;
                        }
                }

                $keyArr = array_unique($keyArr);
                sort($keyArr);
                return $keyArr;
        }










        /*******************************************************************
         *
         * Functions for creating links
         *
         *******************************************************************/

        function linkData($page,$oTarget,$no_cache,$script,$overrideArray='',$addParams='',$typeOverride='')    {
                global $TYPO3_CONF_VARS;

                $LD = Array();

                        // Overriding some fields in the page record and still preserves the values by adding them as parameters. Little strange function.
                if (is_array($overrideArray))   {
                        foreach($overrideArray as $theKey => $theNewVal)        {
                                $addParams.= '&real_'.$theKey.'='.rawurlencode($page[$theKey]);
                                $page[$theKey] = $theNewVal;
                        }
                }

                        // Adding Mount Points, "&MP=", parameter for the current page if any is set:
                if (!strstr($addParams,'&MP=')) {
                        if (trim($GLOBALS['TSFE']->MP_defaults[$page['uid']]))  {       // Looking for hardcoded defaults:
                                $addParams.= '&MP='.rawurlencode(trim($GLOBALS['TSFE']->MP_defaults[$page['uid']]));
                        } elseif ($GLOBALS['TSFE']->config['config']['MP_mapRootPoints']) {             // Else look in automatically created map:
                                $m = $this->getFromMPmap($page['uid']);
                                if ($m) {
                                        $addParams.= '&MP='.rawurlencode($m);
                                }
                        }
                }

                        // Setting ID/alias:
                if (!$script)   {$script = $GLOBALS['TSFE']->config['mainScript'];}
                if ($page['alias'])     {
                        $LD['url'] = $script.'?id='.rawurlencode($page['alias']);
                } else {
                        $LD['url'] = $script.'?id='.$page['uid'];
                }
                        // Setting target
                $LD['target'] = trim($page['target']) ? trim($page['target']) : $oTarget;

                        // typeNum
                $typeNum = $this->setup[$LD['target'].'.']['typeNum'];
                if (!$typeOverride && intval($GLOBALS['TSFE']->config['config']['forceTypeValue']))     {
                        $typeOverride = intval($GLOBALS['TSFE']->config['config']['forceTypeValue']);
                }
                if (strcmp($typeOverride,''))   { $typeNum = $typeOverride; }   // Override...
                if ($typeNum)   {
                        $LD['type'] = '&type='.intval($typeNum);
                } else {
                        $LD['type'] = '';
                }
                $LD['orig_type'] = $LD['type'];         // Preserving the type number. Will not be cleared if simulateStaticDocuments.

                        // noCache
                $LD['no_cache'] = (trim($page['no_cache']) || $no_cache) ? '&no_cache=1' : '';

                        // linkVars
                if ($GLOBALS['TSFE']->config['config']['uniqueLinkVars']) {
                        if ($addParams) {
                                $LD['linkVars'] = t3lib_div::implodeArrayForUrl('',t3lib_div::explodeUrl2Array($GLOBALS['TSFE']->linkVars.$addParams));
                        } else {
                                $LD['linkVars'] = $GLOBALS['TSFE']->linkVars;
                        }
                } else {
                        $LD['linkVars'] = $GLOBALS['TSFE']->linkVars.$addParams;
                }

                        // If simulateStaticDocuments is enabled:
                if ($GLOBALS['TSFE']->config['config']['simulateStaticDocuments'])      {
                        $LD['type'] = '';
                        $LD['url'] = '';

                                // MD5/base64 method limitation:
                        $remainLinkVars='';
                        $flag_simulateStaticDocuments_pEnc = t3lib_div::inList('md5,base64',$GLOBALS['TSFE']->config['config']['simulateStaticDocuments_pEnc']) && !$LD['no_cache'];
                        if ($flag_simulateStaticDocuments_pEnc) {
                                list($LD['linkVars'], $remainLinkVars) = $GLOBALS['TSFE']->simulateStaticDocuments_pEnc_onlyP_proc($LD['linkVars']);
                        }

                        $LD['url'].=$GLOBALS['TSFE']->makeSimulFileName(
                                                        $page['title'],
                                                        $page['alias'] ? $page['alias'] : $page['uid'],
                                                        intval($typeNum),
                                                        $LD['linkVars'],
                                                        $LD['no_cache']?1:0
                                                );

                        if ($flag_simulateStaticDocuments_pEnc) {
                                $LD['linkVars']=$remainLinkVars;
                        }
                        if ($GLOBALS['TSFE']->config['config']['simulateStaticDocuments']=='PATH_INFO') {
                                $LD['url'] = str_replace('.','/',$LD['url']);
                                $LD['url'] = 'index.php/'.$LD['url'].'/?';
                        } else {
                                $LD['url'].= '.html?';
                        }
                }

                        // Add absRefPrefix if exists.
                $LD['url'] = $GLOBALS['TSFE']->absRefPrefix.$LD['url'];

                        // If the special key 'sectionIndex_uid' (added 'manually' in tslib/menu.php to the page-record) is set, then the link jumps directly to a section on the page.
                $LD['sectionIndex'] = $page['sectionIndex_uid'] ? '#c'.$page['sectionIndex_uid'] : '';

                        // Compile the normal total url
                $LD['totalURL']= $this->removeQueryString($LD['url'].$LD['type'].$LD['no_cache'].$LD['linkVars'].$GLOBALS['TSFE']->getMethodUrlIdToken).$LD['sectionIndex'];

                        // Call post processing function for link rendering:
                if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['linkData-PostProc']))  {
                        $_params = array(
                                                        'LD' => &$LD,
                                                        'args' => array('page'=>$page, 'oTarget'=>$oTarget, 'no_cache'=>$no_cache, 'script'=>$script, 'overrideArray'=>$overrideArray, 'addParams'=>$addParams, 'typeOverride'=>$typeOverride),
                                                        'typeNum' => $typeNum
                                                );
                        foreach($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['linkData-PostProc'] as $_funcRef)   {
                                t3lib_div::callUserFunction($_funcRef,$_params,$this);
                        }
                }

                        // Return the LD-array
                return $LD;
        }

        function getFromMPmap($pageId=0)        {

                        // Create map if not found already:
                if (!is_array($this->MPmap))    {
                        $this->MPmap = array();

                        $rootPoints = t3lib_div::trimExplode(',', strtolower($GLOBALS['TSFE']->config['config']['MP_mapRootPoints']),1);
                        foreach($rootPoints as $p)      {       // Traverse rootpoints:
                                if ($p == 'root')       {
                                        $p = $this->rootLine[0]['uid'];
                                        $initMParray = array();
                                        if ($this->rootLine[0]['_MOUNT_OL'] && $this->rootLine[0]['_MP_PARAM']) {
                                                $initMParray[] = $this->rootLine[0]['_MP_PARAM'];
                                        }
                                }
                                $this->initMPmap_create($p,$initMParray);
                        }
                }

                        // Finding MP var for Page ID:
                if ($pageId)    {
                        if (is_array($this->MPmap[$pageId]) && count($this->MPmap[$pageId]))    {
                                return implode(',',$this->MPmap[$pageId]);
                        }
                }
        }

        function initMPmap_create($id,$MP_array=array(),$level=0)       {

                $id = intval($id);
                if($id<=0)      return;

                        // First level, check id
                if (!$level)    {

                                // Find mount point if any:
                        $mount_info = $GLOBALS['TSFE']->sys_page->getMountPointInfo($id);

                                // Overlay mode:
                        if (is_array($mount_info) && $mount_info['overlay'])    {
                                $MP_array[] = $mount_info['MPvar'];
                                $id = $mount_info['mount_pid'];
                        }

                                // Set mapping information for this level:
                        $this->MPmap[$id] = $MP_array;

                                // Normal mode:
                        if (is_array($mount_info) && !$mount_info['overlay'])   {
                                $MP_array[] = $mount_info['MPvar'];
                                $id = $mount_info['mount_pid'];
                        }
                }

                if ($id && $level<20)   {

                        $nextLevelAcc = array();

                                // Select and traverse current level pages:
                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                                                'uid,pid,doktype,mount_pid,mount_pid_ol',
                                                'pages',
                                                'pid='.intval($id).' AND deleted=0 AND doktype!=255 AND doktype!=6'     // 255 = Garbage bin, 6 = Backend User Section
                                        );
                        while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {

                                        // Find mount point if any:
                                $next_id = $row['uid'];
                                $next_MP_array = $MP_array;
                                $mount_info = $GLOBALS['TSFE']->sys_page->getMountPointInfo($next_id, $row);

                                        // Overlay mode:
                                if (is_array($mount_info) && $mount_info['overlay'])    {
                                        $next_MP_array[] = $mount_info['MPvar'];
                                        $next_id = $mount_info['mount_pid'];
                                }

                                if (!isset($this->MPmap[$next_id]))     {

                                                // Set mapping information for this level:
                                        $this->MPmap[$next_id] = $next_MP_array;

                                                // Normal mode:
                                        if (is_array($mount_info) && !$mount_info['overlay'])   {
                                                $next_MP_array[] = $mount_info['MPvar'];
                                                $next_id = $mount_info['mount_pid'];
                                        }

                                                // Register recursive call
                                                // (have to do it this way since ALL of the current level should be registered BEFORE the sublevel at any time)
                                        $nextLevelAcc[] = array($next_id,$next_MP_array);
                                }
                        }

                                // Call recursively, if any:
                        foreach($nextLevelAcc as $pSet) {
                                $this->initMPmap_create($pSet[0],$pSet[1],$level+1);
                        }
                }
        }
}


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