Documentation TYPO3 par Ameos

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

class.tslib_menu.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2005 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!
***************************************************************/
class tslib_menu {
        var $menuNumber = 1;                            // tells you which menu-number this is. This is important when getting data from the setup
        var $entryLevel = 0;                            // 0 = rootFolder
        var $spacerIDList = '199';                      // The doktype-number that defines a spacer
        var $doktypeExcludeList = '5,6';                        // doktypes that define which should not be included in a menu
        var $alwaysActivePIDlist=array();
        var $imgNamePrefix = 'img';
        var $imgNameNotRandom=0;
        var $debug = 0;
        var $parent_cObj ='';                           // Loaded with the parent cObj-object when a new HMENU is made
        var $GMENU_fixKey='gmenu';
        var $MP_array=array();                          // accumulation of mount point data

                // internal
        var $conf = Array();                            // HMENU configuration
        var $mconf = Array();                           // xMENU configuration (TMENU, GMENU etc)
        var $tmpl;              // template-object
        var $sys_page;  // sys_page-object
        var $id;                                                        // The base page-id of the menu.
        var $nextActive;                                        // Holds the page uid of the NEXT page in the root line from the page pointed to by entryLevel; Used to expand the menu automatically if in a certain root line.
        var $menuArr;   // The array of menuItems which is built
        var $hash;
        var $result = Array();
        var $rL_uidRegister = '';                       // Array: Is filled with an array of page uid numbers + RL parameters which are in the current root line (used to evaluate whether a menu item is in active state)
        var $INPfixMD5;
        var $I;
        var $WMresult;
        var $WMfreezePrefix;
        var $WMmenuItems;
        var $WMsubmenuObjSuffixes;
        var $WMextraScript;
        var $alternativeMenuTempArray='';               // Can be set to contain menu item arrays for sub-levels.
        var $nameAttribute = 'name';                    // Will be 'id' in XHTML-mode

        function start(&$tmpl,&$sys_page,$id,$conf,$menuNumber,$objSuffix='')   {

                        // Init:
                $this->conf = $conf;
                $this->menuNumber = $menuNumber;
                $this->mconf = $conf[$this->menuNumber.$objSuffix.'.'];
                $this->debug=$GLOBALS['TSFE']->debug;

                        // In XHTML there is no "name" attribute anymore
                switch ($GLOBALS['TSFE']->xhtmlDoctype) {
                        case 'xhtml_strict':
                        case 'xhtml_11':
                        case 'xhtml_2':
                                $this->nameAttribute = 'id';
                                break;
                        default:
                                $this->nameAttribute = 'name';
                                break;
                }

                        // Sets the internal vars. $tmpl MUST be the template-object. $sys_page MUST be the sys_page object
                if ($this->conf[$this->menuNumber.$objSuffix] && is_object($tmpl) && is_object($sys_page))      {
                        $this->tmpl = &$tmpl;
                        $this->sys_page = &$sys_page;

                                // alwaysActivePIDlist initialized:
                        if (trim($this->conf['alwaysActivePIDlist']))   {
                                $this->alwaysActivePIDlist = t3lib_div::intExplode(',', $this->conf['alwaysActivePIDlist']);
                        }

                                // 'not in menu' doktypes
                        if($this->conf['excludeDoktypes']) {
                                $this->doktypeExcludeList = $GLOBALS['TYPO3_DB']->cleanIntList($this->conf['excludeDoktypes']);
                        }
                        if($this->conf['includeNotInMenu']) {
                                $exclDoktypeArr = t3lib_div::trimExplode(',',$this->doktypeExcludeList,1);
                                $exclDoktypeArr = t3lib_div::removeArrayEntryByValue($exclDoktypeArr,'5');
                                $this->doktypeExcludeList = implode(',',$exclDoktypeArr);
                        }

                                // EntryLevel
                        $this->entryLevel = tslib_cObj::getKey ($conf['entryLevel'],$this->tmpl->rootLine);

                                // Set parent page: If $id not stated with start() then the base-id will be found from rootLine[$this->entryLevel]
                        if ($id)        {       // Called as the next level in a menu. It is assumed that $this->MP_array is set from parent menu.
                                $this->id = intval($id);
                        } else {        // This is a BRAND NEW menu, first level. So we take ID from rootline and also find MP_array (mount points)
                                $this->id = intval($this->tmpl->rootLine[$this->entryLevel]['uid']);

                                        // Traverse rootline to build MP_array of pages BEFORE the entryLevel
                                        // (MP var for ->id is picked up in the next part of the code...)
                                foreach($this->tmpl->rootLine as $entryLevel => $levelRec)      {
                                                // For overlaid mount points, set the variable right now:
                                        if ($levelRec['_MP_PARAM'] && $levelRec['_MOUNT_OL'])   {
                                                $this->MP_array[] = $levelRec['_MP_PARAM'];
                        }
                                                // Break when entry level is reached:
                                        if ($entryLevel>=$this->entryLevel)     break;

                                                // For normal mount points, set the variable for next level.
                                        if ($levelRec['_MP_PARAM'] && !$levelRec['_MOUNT_OL'])  {
                                                $this->MP_array[] = $levelRec['_MP_PARAM'];
                                        }
                                }
                        }

                                // Return false if no page ID was set (thus no menu of subpages can be made).
                        if ($this->id<=0)       {
                                return FALSE;
                        }

                                // Check if page is a mount point, and if so set id and MP_array
                                // (basically this is ONLY for non-overlay mode, but in overlay mode an ID with a mount point should never reach this point anyways, so no harm done...)
                        $mount_info = $this->sys_page->getMountPointInfo($this->id);
                        if (is_array($mount_info))      {
                                $this->MP_array[] = $mount_info['MPvar'];
                                $this->id = $mount_info['mount_pid'];
                        }

                                // Gather list of page uids in root line (for "isActive" evaluation). Also adds the MP params in the path so Mount Points are respected.
                                // (List is specific for this rootline, so it may be supplied from parent menus for speed...)
                        if (!is_array($this->rL_uidRegister))   {
                                $rl_MParray = array();
                                foreach($this->tmpl->rootLine as $v_rl) {
                                                // For overlaid mount points, set the variable right now:
                                        if ($v_rl['_MP_PARAM'] && $v_rl['_MOUNT_OL'])   {
                                                $rl_MParray[] = $v_rl['_MP_PARAM'];
                                        }

                                                // Add to register:
                                        $this->rL_uidRegister[] = 'ITEM:'.$v_rl['uid'].(count($rl_MParray) ? ':'.implode(',',$rl_MParray) : '');

                                                // For normal mount points, set the variable for next level.
                                        if ($v_rl['_MP_PARAM'] && !$v_rl['_MOUNT_OL'])  {
                                                $rl_MParray[] = $v_rl['_MP_PARAM'];
                                        }
                                }
                        }

                                // Setting "nextActive": This is the page uid + MPvar of the NEXT page in rootline. Used to expand the menu if we are in the right branch of the tree
                                // Notice: The automatic expansion of a menu is designed to work only when no "special" modes are used.
                        if (is_array($this->tmpl->rootLine[$this->entryLevel+$this->menuNumber]))       {
                                $nextMParray = $this->MP_array;
                                if ($this->tmpl->rootLine[$this->entryLevel+$this->menuNumber]['_MOUNT_OL'])    {       // In overlay mode, add next level MPvars as well:
                                        $nextMParray[] = $this->tmpl->rootLine[$this->entryLevel+$this->menuNumber]['_MP_PARAM'];
                                }
                                $this->nextActive = $this->tmpl->rootLine[$this->entryLevel+$this->menuNumber]['uid'].
                                                                                (count($nextMParray)?':'.implode(',',$nextMParray):'');
                        } else {
                                $this->nextActive = '';
                        }

                                // imgNamePrefix
                        if ($this->mconf['imgNamePrefix']) {
                                $this->imgNamePrefix=$this->mconf['imgNamePrefix'];
                        }
                        $this->imgNameNotRandom = $this->mconf['imgNameNotRandom'];

                        $retVal = TRUE;
                } else {
                        $GLOBALS['TT']->setTSlogMessage('ERROR in menu',3);
                        $retVal = FALSE;
                }
                return $retVal;
        }

        function makeMenu()     {
                if ($this->id)  {

                                // Initializing showAccessRestrictedPages
                        if ($this->mconf['showAccessRestrictedPages'])  {
                                        // SAVING where_groupAccess
                                $SAVED_where_groupAccess = $this->sys_page->where_groupAccess;
                                $this->sys_page->where_groupAccess = '';        // Temporarily removing fe_group checking!
                        }

                                // Begin production of menu:
                        $temp = array();
                        $altSortFieldValue = trim($this->mconf['alternativeSortingField']);
                        $altSortField = $altSortFieldValue ? $altSortFieldValue : 'sorting';
                        if ($this->menuNumber==1 && $this->conf['special'])     {               // ... only for the FIRST level of a HMENU
                                $value = $this->conf['special.']['value'];

                                switch($this->conf['special'])  {
                                        case 'userdefined':
                                                $temp = $this->includeMakeMenu($this->conf['special.'],$altSortField);
                                        break;
                                        case 'userfunction':
                                                $temp = $this->parent_cObj->callUserFunction(
                                                        $this->conf['special.']['userFunc'],
                                                        array_merge($this->conf['special.'],array('_altSortField'=>$altSortField)),
                                                        ''
                                                );
                                                if (!is_array($temp))   $temp=array();
                                        break;
                                        case 'language':
                                                $temp = array();

                                                        // Getting current page record NOT overlaid by any translation:
                                                $currentPageWithNoOverlay = $this->sys_page->getRawRecord('pages',$GLOBALS['TSFE']->page['uid']);

                                                        // Traverse languages set up:
                                                $languageItems = t3lib_div::intExplode(',',$value);
                                                foreach($languageItems as $sUid)        {
                                                                // Find overlay record:
                                                        if ($sUid)      {
                                                                $lRecs = $this->sys_page->getPageOverlay($GLOBALS['TSFE']->page['uid'],$sUid);
                                                        } else $lRecs=array();
                                                                // Checking if the "disabled" state should be set.
                                                        if (
                                                                                (t3lib_div::hideIfNotTranslated($GLOBALS['TSFE']->page['l18n_cfg']) && $sUid && !count($lRecs)) // Blocking for all translations?
                                                                        || ($GLOBALS['TSFE']->page['l18n_cfg']&1 && (!$sUid || !count($lRecs))) // Blocking default translation?
                                                                        || (!$this->conf['special.']['normalWhenNoLanguage'] && $sUid && !count($lRecs))
                                                                )       {
                                                                $iState = $GLOBALS['TSFE']->sys_language_uid==$sUid ? 'USERDEF2' : 'USERDEF1';
                                                        } else {
                                                                $iState = $GLOBALS['TSFE']->sys_language_uid==$sUid ? 'ACT' : 'NO';
                                                        }

                                                        if ($this->conf['addQueryString'])      {
                                                                $getVars = $this->parent_cObj->getQueryArguments($this->conf['addQueryString.'],array('L'=>$sUid),true);
                                                        } else {
                                                                $getVars = '&L='.$sUid;
                                                        }

                                                                // Adding menu item:
                                                        $temp[] = array_merge(
                                                                array_merge($currentPageWithNoOverlay, $lRecs),
                                                                array(
                                                                        'ITEM_STATE' => $iState,
                                                                        '_ADD_GETVARS' => $getVars,
                                                                        '_SAFE' => TRUE
                                                                )
                                                        );
                                                }
                                        break;
                                        case 'directory':
                                                if ($value=='') {
                                                        $value=$GLOBALS['TSFE']->page['uid'];
                                                }
                                                $items=t3lib_div::intExplode(',',$value);

                                                foreach($items as $id)  {
                                                        $MP = $this->tmpl->getFromMPmap($id);

                                                                // Checking if a page is a mount page and if so, change the ID and set the MP var properly.
                                                        $mount_info = $this->sys_page->getMountPointInfo($id);
                                                        if (is_array($mount_info))      {
                                                                if ($mount_info['overlay'])     {       // Overlays should already have their full MPvars calculated:
                                                                        $MP = $this->tmpl->getFromMPmap($mount_info['mount_pid']);
                                                                        $MP = $MP ? $MP : $mount_info['MPvar'];
                                                                } else {
                                                                        $MP = ($MP ? $MP.',' : '').$mount_info['MPvar'];
                                                                }
                                                                $id = $mount_info['mount_pid'];
                                                        }

                                                                // Get sub-pages:
                                                        $res = $GLOBALS['TSFE']->cObj->exec_getQuery('pages',Array('pidInList'=>$id,'orderBy'=>$altSortField));
                                                        while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {
                                                                $GLOBALS['TSFE']->sys_page->versionOL('pages',$row);

                                                                if (is_array($row))     {
                                                                                // Keep mount point?
                                                                        $mount_info = $this->sys_page->getMountPointInfo($row['uid'], $row);
                                                                        if (is_array($mount_info) && $mount_info['overlay'])    {       // There is a valid mount point.
                                                                                $mp_row = $this->sys_page->getPage($mount_info['mount_pid']);           // Using "getPage" is OK since we need the check for enableFields AND for type 2 of mount pids we DO require a doktype < 200!
                                                                                if (count($mp_row))     {
                                                                                        $row = $mp_row;
                                                                                        $row['_MP_PARAM'] = $mount_info['MPvar'];
                                                                                } else unset($row);     // If the mount point could not be fetched with respect to enableFields, unset the row so it does not become a part of the menu!
                                                                        }

                                                                                // Add external MP params, then the row:
                                                                        if (is_array($row))     {
                                                                                if ($MP)        $row['_MP_PARAM'] = $MP.($row['_MP_PARAM'] ? ','.$row['_MP_PARAM'] : '');
                                                                                $temp[$row['uid']] = $this->sys_page->getPageOverlay($row);
                                                                        }
                                                                }
                                                        }
                                                }
                                        break;
                                        case 'list':
                                                if ($value=='') {
                                                        $value=$this->id;
                                                }
                                                $loadDB = t3lib_div::makeInstance('FE_loadDBGroup');
                                                $loadDB->start($value, 'pages');
                                                $loadDB->additionalWhere['pages']=tslib_cObj::enableFields('pages');
                                                $loadDB->getFromDB();

                                                foreach($loadDB->itemArray as $val)     {
                                                        $MP = $this->tmpl->getFromMPmap($val['id']);

                                                                // Keep mount point?
                                                        $mount_info = $this->sys_page->getMountPointInfo($val['id']);
                                                        if (is_array($mount_info) && $mount_info['overlay'])    {       // There is a valid mount point.
                                                                $mp_row = $this->sys_page->getPage($mount_info['mount_pid']);           // Using "getPage" is OK since we need the check for enableFields AND for type 2 of mount pids we DO require a doktype < 200!
                                                                if (count($mp_row))     {
                                                                        $row = $mp_row;
                                                                        $row['_MP_PARAM'] = $mount_info['MPvar'];

                                                                        if ($mount_info['overlay'])     {       // Overlays should already have their full MPvars calculated:
                                                                                $MP = $this->tmpl->getFromMPmap($mount_info['mount_pid']);
                                                                                if ($MP) unset($row['_MP_PARAM']);
                                                                        }
                                                                } else unset($row);     // If the mount point could not be fetched with respect to enableFields, unset the row so it does not become a part of the menu!
                                                        } else {
                                                                $row = $loadDB->results['pages'][$val['id']];
                                                        }

                                                                // Add external MP params, then the row:
                                                        if (is_array($row))     {
                                                                if ($MP)        $row['_MP_PARAM'] = $MP.($row['_MP_PARAM'] ? ','.$row['_MP_PARAM'] : '');
                                                                $temp[] = $this->sys_page->getPageOverlay($row);
                                                        }
                                                }
                                        break;
                                        case 'updated':
                                                if ($value=='') {
                                                        $value=$GLOBALS['TSFE']->page['uid'];
                                                }
                                                $items=t3lib_div::intExplode(',',$value);
                                                if (t3lib_div::testInt($this->conf['special.']['depth']))       {
                                                        $depth = t3lib_div::intInRange($this->conf['special.']['depth'],1,20);          // Tree depth
                                                } else {
                                                        $depth=20;
                                                }
                                                $limit = t3lib_div::intInRange($this->conf['special.']['limit'],0,100); // max number of items
                                                $maxAge = intval(tslib_cObj::calc($this->conf['special.']['maxAge']));
                                                if (!$limit)    $limit=10;
                                                $mode = $this->conf['special.']['mode'];        // *'auto', 'manual', 'tstamp'
                                                        // Get id's
                                                $id_list_arr = Array();

                                                foreach($items as $id)  {
                                                        $bA = t3lib_div::intInRange($this->conf['special.']['beginAtLevel'],0,100);
                                                        $id_list_arr[] = tslib_cObj::getTreeList(-1*$id,$depth-1+$bA,$bA-1);
                                                }
                                                $id_list = implode(',',$id_list_arr);
                                                        // Get sortField (mode)
                                                switch($mode)   {
                                                        case 'starttime':
                                                                $sortField = 'starttime';
                                                        break;
                                                        case 'lastUpdated':
                                                        case 'manual':
                                                                $sortField = 'lastUpdated';
                                                        break;
                                                        case 'tstamp':
                                                                $sortField = 'tstamp';
                                                        break;
                                                        case 'crdate':
                                                                $sortField = 'crdate';
                                                        break;
                                                        default:
                                                                $sortField = 'SYS_LASTCHANGED';
                                                        break;
                                                }
                                                        // Get
                                                $extraWhere = ($this->conf['includeNotInMenu'] ? '' : ' AND pages.nav_hide=0').$this->getDoktypeExcludeWhere();

                                                if ($this->conf['special.']['excludeNoSearchPages']) {
                                                        $extraWhere.= ' AND pages.no_search=0';
                                                }
                                                if ($maxAge>0)  {
                                                        $extraWhere.=' AND '.$sortField.'>'.($GLOBALS['SIM_EXEC_TIME']-$maxAge);
                                                }

                                                $res = $GLOBALS['TSFE']->cObj->exec_getQuery('pages',Array('pidInList'=>'0', 'uidInList'=>$id_list, 'where'=>$sortField.'>=0'.$extraWhere, 'orderBy'=>($altSortFieldValue ? $altSortFieldValue : $sortField.' desc'),'max'=>$limit));
                                                while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {
                                                        $GLOBALS['TSFE']->sys_page->versionOL('pages',$row);
                                                        if (is_array($row))     {
                                                                $temp[$row['uid']]=$this->sys_page->getPageOverlay($row);
                                                        }
                                                }
                                        break;
                                        case 'keywords':
                                                list($value)=t3lib_div::intExplode(',',$value);
                                                if (!$value) {
                                                        $value=$GLOBALS['TSFE']->page['uid'];
                                                }
                                                if ($this->conf['special.']['setKeywords'] || $this->conf['special.']['setKeywords.']) {
                                                        $kw = $this->parent_cObj->stdWrap($this->conf['special.']['setKeywords'], $this->conf['special.']['setKeywords.']);
                                                } else {
                                                        $value_rec=$this->sys_page->getPage($value);    // The page record of the 'value'.

                                                        $kfieldSrc = $this->conf['special.']['keywordsField.']['sourceField'] ? $this->conf['special.']['keywordsField.']['sourceField'] : 'keywords';
                                                        $kw = trim(tslib_cObj::keywords($value_rec[$kfieldSrc]));               // keywords.
                                                }

                                                $mode = $this->conf['special.']['mode'];        // *'auto', 'manual', 'tstamp'
                                                switch($mode)   {
                                                        case 'starttime':
                                                                $sortField = 'starttime';
                                                        break;
                                                        case 'lastUpdated':
                                                        case 'manual':
                                                                $sortField = 'lastUpdated';
                                                        break;
                                                        case 'tstamp':
                                                                $sortField = 'tstamp';
                                                        break;
                                                        case 'crdate':
                                                                $sortField = 'crdate';
                                                        break;
                                                        default:
                                                                $sortField = 'SYS_LASTCHANGED';
                                                        break;
                                                }

                                                        // depth, limit, extra where
                                                if (t3lib_div::testInt($this->conf['special.']['depth']))       {
                                                        $depth = t3lib_div::intInRange($this->conf['special.']['depth'],0,20);          // Tree depth
                                                } else {
                                                        $depth=20;
                                                }
                                                $limit = t3lib_div::intInRange($this->conf['special.']['limit'],0,100); // max number of items
                                                $extraWhere = ' AND pages.uid!='.$value.($this->conf['includeNotInMenu'] ? '' : ' AND pages.nav_hide=0').$this->getDoktypeExcludeWhere();
                                                if ($this->conf['special.']['excludeNoSearchPages']) {
                                                        $extraWhere.= ' AND pages.no_search=0';
                                                }
                                                        // start point
                                                $eLevel = tslib_cObj::getKey (intval($this->conf['special.']['entryLevel']),$this->tmpl->rootLine);
                                                $startUid = intval($this->tmpl->rootLine[$eLevel]['uid']);

                                                        // which field is for keywords
                                                $kfield = 'keywords';
                                                if ( $this->conf['special.']['keywordsField'] ) {
                                                        list($kfield) = explode(' ',trim ($this->conf['special.']['keywordsField']));
                                                }

                                                        // If there are keywords and the startuid is present.
                                                if ($kw && $startUid)   {
                                                        $bA = t3lib_div::intInRange($this->conf['special.']['beginAtLevel'],0,100);
                                                        $id_list=tslib_cObj::getTreeList(-1*$startUid,$depth-1+$bA,$bA-1);

                                                        $kwArr = explode(',',$kw);
                                                        foreach($kwArr as $word)        {
                                                                $word = trim($word);
                                                                if ($word)      {
                                                                        $keyWordsWhereArr[] = $kfield.' LIKE \'%'.$GLOBALS['TYPO3_DB']->quoteStr($word, 'pages').'%\'';
                                                                }
                                                        }
                                                        $res = $GLOBALS['TSFE']->cObj->exec_getQuery('pages',Array('pidInList'=>'0', 'uidInList'=>$id_list, 'where'=>'('.implode(' OR ',$keyWordsWhereArr).')'.$extraWhere, 'orderBy'=>($altSortFieldValue ? $altSortFieldValue : $sortField.' desc'),'max'=>$limit));
                                                        while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {
                                                                $GLOBALS['TSFE']->sys_page->versionOL('pages',$row);
                                                                if (is_array($row))     {
                                                                        $temp[$row['uid']]=$this->sys_page->getPageOverlay($row);
                                                                }
                                                        }
                                                }
                                        break;
                                        case 'rootline':
                                                $begin_end = explode('|',$this->conf['special.']['range']);
                                                if (!t3lib_div::testInt($begin_end[0])) {intval($begin_end[0]);}
                                                if (!t3lib_div::testInt($begin_end[1])) {$begin_end[1]=-1;}

                                                $beginKey = tslib_cObj::getKey ($begin_end[0],$this->tmpl->rootLine);
                                                $endKey = tslib_cObj::getKey ($begin_end[1],$this->tmpl->rootLine);
                                                if ($endKey<$beginKey)  {$endKey=$beginKey;}

                                                $rl_MParray = array();
                                                foreach($this->tmpl->rootLine as $k_rl => $v_rl)        {
                                                                // For overlaid mount points, set the variable right now:
                                                        if ($v_rl['_MP_PARAM'] && $v_rl['_MOUNT_OL'])   {
                                                                $rl_MParray[] = $v_rl['_MP_PARAM'];
                                                        }
                                                                // Traverse rootline:
                                                        if ($k_rl>=$beginKey && $k_rl<=$endKey) {
                                                                $temp_key=$k_rl;
                                                                $temp[$temp_key]=$this->sys_page->getPage($v_rl['uid']);
                                                                if (count($temp[$temp_key]))    {
                                                                        if (!$temp[$temp_key]['target'])        {       // If there are no specific target for the page, put the level specific target on.
                                                                                $temp[$temp_key]['target'] = $this->conf['special.']['targets.'][$k_rl];
                                                                                $temp[$temp_key]['_MP_PARAM'] = implode(',',$rl_MParray);
                                                                        }
                                                                } else unset($temp[$temp_key]);
                                                        }
                                                                // For normal mount points, set the variable for next level.
                                                        if ($v_rl['_MP_PARAM'] && !$v_rl['_MOUNT_OL'])  {
                                                                $rl_MParray[] = $v_rl['_MP_PARAM'];
                                                }
                                                }
                                        break;
                                        case 'browse':
                                                list($value)=t3lib_div::intExplode(',',$value);
                                                if (!$value) {
                                                        $value=$GLOBALS['TSFE']->page['uid'];
                                                }
                                                if ($value!=$this->tmpl->rootLine[0]['uid'])    {       // Will not work out of rootline
                                                        $recArr=array();
                                                        $value_rec=$this->sys_page->getPage($value);    // The page record of the 'value'.
                                                        if ($value_rec['pid'])  {       // 'up' page cannot be outside rootline
                                                                $recArr['up']=$this->sys_page->getPage($value_rec['pid']);      // The page record of 'up'.
                                                        }
                                                        if ($recArr['up']['pid'] && $value_rec['pid']!=$this->tmpl->rootLine[0]['uid']) {       // If the 'up' item was NOT level 0 in rootline...
                                                                $recArr['index']=$this->sys_page->getPage($recArr['up']['pid']);        // The page record of "index".
                                                        }

                                                                // prev / next is found
                                                        $prevnext_menu = $this->sys_page->getMenu($value_rec['pid'],'*',$altSortField);
                                                        $lastKey=0;
                                                        $nextActive=0;
                                                        reset($prevnext_menu);
                                                        while(list($k_b,$v_b)=each($prevnext_menu))     {
                                                                if ($nextActive)        {
                                                                        $recArr['next']=$v_b;
                                                                        $nextActive=0;
                                                                }
                                                                if ($v_b['uid']==$value)        {
                                                                        if ($lastKey)   {
                                                                                $recArr['prev']=$prevnext_menu[$lastKey];
                                                                        }
                                                                        $nextActive=1;
                                                                }
                                                                $lastKey=$k_b;
                                                        }
                                                        reset($prevnext_menu);
                                                        $recArr['first']=pos($prevnext_menu);
                                                        end($prevnext_menu);
                                                        $recArr['last']=pos($prevnext_menu);

                                                                // prevsection / nextsection is found
                                                        if (is_array($recArr['index'])) {       // You can only do this, if there is a valid page two levels up!
                                                                $prevnextsection_menu = $this->sys_page->getMenu($recArr['index']['uid'],'*',$altSortField);
                                                                $lastKey=0;
                                                                $nextActive=0;
                                                                reset($prevnextsection_menu);
                                                                while(list($k_b,$v_b)=each($prevnextsection_menu))      {
                                                                        if ($nextActive)        {
                                                                                $sectionRec_temp = $this->sys_page->getMenu($v_b['uid'],'*',$altSortField);
                                                                                if (count($sectionRec_temp))    {
                                                                                        reset($sectionRec_temp);
                                                                                        $recArr['nextsection']=pos($sectionRec_temp);
                                                                                        end ($sectionRec_temp);
                                                                                        $recArr['nextsection_last']=pos($sectionRec_temp);
                                                                                        $nextActive=0;
                                                                                }
                                                                        }
                                                                        if ($v_b['uid']==$value_rec['pid'])     {
                                                                                if ($lastKey)   {
                                                                                        $sectionRec_temp = $this->sys_page->getMenu($prevnextsection_menu[$lastKey]['uid'],'*',$altSortField);
                                                                                        if (count($sectionRec_temp))    {
                                                                                                reset($sectionRec_temp);
                                                                                                $recArr['prevsection']=pos($sectionRec_temp);
                                                                                                end ($sectionRec_temp);
                                                                                                $recArr['prevsection_last']=pos($sectionRec_temp);
                                                                                        }
                                                                                }
                                                                                $nextActive=1;
                                                                        }
                                                                        $lastKey=$k_b;
                                                                }
                                                        }
                                                        if ($this->conf['special.']['items.']['prevnextToSection'])     {
                                                                if (!is_array($recArr['prev']) && is_array($recArr['prevsection_last']))        {
                                                                        $recArr['prev']=$recArr['prevsection_last'];
                                                                }
                                                                if (!is_array($recArr['next']) && is_array($recArr['nextsection']))     {
                                                                        $recArr['next']=$recArr['nextsection'];
                                                                }
                                                        }

                                                        $items = explode('|',$this->conf['special.']['items']);
                                                        $c=0;
                                                        while(list($k_b,$v_b)=each($items))     {
                                                                $v_b=strtolower(trim($v_b));
                                                                if (intval($this->conf['special.'][$v_b.'.']['uid']))   {
                                                                        $recArr[$v_b] = $this->sys_page->getPage(intval($this->conf['special.'][$v_b.'.']['uid']));     // fetches the page in case of a hardcoded pid in template
                                                                }
                                                                if (is_array($recArr[$v_b]))    {
                                                                        $temp[$c]=$recArr[$v_b];
                                                                        if ($this->conf['special.'][$v_b.'.']['target'])        {
                                                                                $temp[$c]['target']=$this->conf['special.'][$v_b.'.']['target'];
                                                                        }
                                                                        if (is_array($this->conf['special.'][$v_b.'.']['fields.']))     {
                                                                                reset($this->conf['special.'][$v_b.'.']['fields.']);
                                                                                while(list($fk,$val)=each($this->conf['special.'][$v_b.'.']['fields.']))        {
                                                                                        $temp[$c][$fk]=$val;
                                                                                }
                                                                        }
                                                                        $c++;
                                                                }
                                                        }
                                                }
                                        break;
                                }
                        } elseif (is_array($this->alternativeMenuTempArray))    {       // Setting $temp array if not level 1.
                                $temp = $this->alternativeMenuTempArray;
                        } elseif ($this->mconf['sectionIndex']) {
                                if ($GLOBALS['TSFE']->sys_language_uid && count($this->sys_page->getPageOverlay($this->id)))    {
                                        $sys_language_uid = intval($GLOBALS['TSFE']->sys_language_uid);
                                } else $sys_language_uid=0;

                                $selectSetup = Array(
                                        'pidInList'=>$this->id,
                                        'orderBy'=>$altSortField,
                                        'where' => 'colPos=0 AND sys_language_uid='.$sys_language_uid,
                                        'andWhere' => 'sectionIndex!=0'
                                        );
                                switch($this->mconf['sectionIndex.']['type'])   {
                                        case 'all':
                                                unset($selectSetup['andWhere']);
                                        break;
                                        case 'header':
                                                $selectSetup['andWhere']='header_layout!=100 AND header!=""';
                                        break;
                                }
                                $basePageRow=$this->sys_page->getPage($this->id);
                                if (is_array($basePageRow))     {
                                        $res = $GLOBALS['TSFE']->cObj->exec_getQuery('tt_content',      $selectSetup);
                                        while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))      {
                                                $GLOBALS['TSFE']->sys_page->versionOL('tt_content',$row);

                                                if (is_array($row))     {
                                                        $temp[$row['uid']]=$basePageRow;
                                                        $temp[$row['uid']]['title']=$row['header'];
                                                        $temp[$row['uid']]['nav_title']=$row['header'];
                                                        $temp[$row['uid']]['subtitle']=$row['subheader'];
                                                        $temp[$row['uid']]['starttime']=$row['starttime'];
                                                        $temp[$row['uid']]['endtime']=$row['endtime'];
                                                        $temp[$row['uid']]['fe_group']=$row['fe_group'];
                                                        $temp[$row['uid']]['media']=$row['media'];

                                                        $temp[$row['uid']]['header_layout']=$row['header_layout'];
                                                        $temp[$row['uid']]['bodytext']=$row['bodytext'];
                                                        $temp[$row['uid']]['image']=$row['image'];

                                                        $temp[$row['uid']]['sectionIndex_uid']=$row['uid'];
                                                }
                                        }
                                }
                        } else {        // Default:
                                $temp = $this->sys_page->getMenu($this->id,'*',$altSortField);          // gets the menu
                        }

                        $c=0;
                        $c_b=0;
                        $minItems = intval($this->mconf['minItems'] ? $this->mconf['minItems'] : $this->conf['minItems']);
                        $maxItems = intval($this->mconf['maxItems'] ? $this->mconf['maxItems'] : $this->conf['maxItems']);
                        $begin = tslib_cObj::calc($this->mconf['begin'] ? $this->mconf['begin'] : $this->conf['begin']);

                        $banUidArray = $this->getBannedUids();

                                // Fill in the menuArr with elements that should go into the menu:
                        $this->menuArr = Array();
                        foreach($temp as $data) {
                                $spacer = (t3lib_div::inList($this->spacerIDList,$data['doktype']) || !strcmp($data['ITEM_STATE'],'SPC')) ? 1 : 0;              // if item is a spacer, $spacer is set
                                if ($this->filterMenuPages($data, $banUidArray, $spacer))       {
                                        $c_b++;
                                        if ($begin<=$c_b)       {               // If the beginning item has been reached.
                                                $this->menuArr[$c] = $data;
                                                $this->menuArr[$c]['isSpacer'] = $spacer;
                                                $c++;
                                                if ($maxItems && $c>=$maxItems) {
                                                        break;
                                                }
                                        }
                                }
                        }

                                // Fill in fake items, if min-items is set.
                        if ($minItems)  {
                                while($c<$minItems)     {
                                        $this->menuArr[$c] = Array(
                                                'title' => '...',
                                                'uid' => $GLOBALS['TSFE']->id
                                        );
                                        $c++;
                                }
                        }
                                // Setting number of menu items
                        $GLOBALS['TSFE']->register['count_menuItems'] = count($this->menuArr);
                                //      Passing the menuArr through a user defined function:
                        if ($this->mconf['itemArrayProcFunc'])  {
                                if (!is_array($this->parentMenuArr)) {$this->parentMenuArr=array();}
                                $this->menuArr = $this->userProcess('itemArrayProcFunc',$this->menuArr);
                        }
                        $this->hash = md5(serialize($this->menuArr).serialize($this->mconf).serialize($this->tmpl->rootLine).serialize($this->MP_array));

                        $serData = $this->sys_page->getHash($this->hash, 60*60*24);
                        if (!$serData)  {
                                $this->generate();
                                $this->sys_page->storeHash($this->hash, serialize($this->result),'MENUDATA');
                        } else {
                                $this->result=unserialize($serData);
                        }

                                // End showAccessRestrictedPages
                        if ($this->mconf['showAccessRestrictedPages'])  {
                                        // RESTORING where_groupAccess
                                $this->sys_page->where_groupAccess = $SAVED_where_groupAccess;
                        }
                }
        }

        function includeMakeMenu($conf,$altSortField)   {
                $incFile = $GLOBALS['TSFE']->tmpl->getFileName($conf['file']);
                if ($incFile && $GLOBALS['TSFE']->checkFileInclude($incFile))   {
                        include($incFile);
                }
                return is_array($menuItemsArray) ? $menuItemsArray : array();
        }

        function filterMenuPages(&$data,$banUidArray,$spacer)   {

                if ($data['_SAFE'])     return TRUE;

                $uid = $data['uid'];
                if ($this->mconf['SPC'] || !$spacer)    {       // If the spacer-function is not enabled, spacers will not enter the $menuArr
                        if (!t3lib_div::inList($this->doktypeExcludeList,$data['doktype']))     {               // Page may not be 'not_in_menu' or 'Backend User Section'
                                if (!$data['nav_hide'] || $this->conf['includeNotInMenu'])      {       // Not hidden in navigation
                                        if (!t3lib_div::inArray($banUidArray,$uid))     {       // not in banned uid's

                                                        // Checks if the default language version can be shown:
                                                        // Block page is set, if l18n_cfg allows plus: 1) Either default language or 2) another language but NO overlay record set for page!
                                                $blockPage = $data['l18n_cfg']&1 && (!$GLOBALS['TSFE']->sys_language_uid || ($GLOBALS['TSFE']->sys_language_uid && !$data['_PAGES_OVERLAY']));
                                                if (!$blockPage)        {

                                                                // Checking if a page should be shown in the menu depending on whether a translation exists:
                                                        $tok = TRUE;
                                                        if ($GLOBALS['TSFE']->sys_language_uid && t3lib_div::hideIfNotTranslated($data['l18n_cfg']))    {       // There is an alternative language active AND the current page requires a translation:
                                                                if (!$data['_PAGES_OVERLAY'])   {
                                                                        $tok = FALSE;
                                                                }
                                                        }

                                                                // Continue if token is true:
                                                        if ($tok)       {

                                                                        // Checking if "&L" should be modified so links to non-accessible pages will not happen.
                                                                if ($this->conf['protectLvar']) {
                                                                        $languageUid = intval($GLOBALS['TSFE']->config['config']['sys_language_uid']);
                                                                        if ($languageUid && ($this->conf['protectLvar']=='all' || t3lib_div::hideIfNotTranslated($data['l18n_cfg'])))   {
                                                                                $olRec = $GLOBALS['TSFE']->sys_page->getPageOverlay($data['uid'], $languageUid);
                                                                                if (!count($olRec))     {
                                                                                                // If no pages_language_overlay record then page can NOT be accessed in the language pointed to by "&L" and therefore we protect the link by setting "&L=0"
                                                                                        $data['_ADD_GETVARS'].= '&L=0';
                                                                                }
                                                                        }
                                                                }

                                                                return TRUE;
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        function procesItemStates($splitCount)  {

                        // Prepare normal settings
                if (!is_array($this->mconf['NO.']) && $this->mconf['NO'])       $this->mconf['NO.']=array();    // Setting a blank array if NO=1 and there are no properties.
                $NOconf = $this->tmpl->splitConfArray($this->mconf['NO.'],$splitCount);

                        // Prepare rollOver settings, overriding normal settings
                $ROconf=array();
                if ($this->mconf['RO']) {
                        $ROconf = $this->tmpl->splitConfArray($this->mconf['RO.'],$splitCount);
                }

                        // Prepare IFSUB settings, overriding normal settings
                        // IFSUB is true if there exist submenu items to the current item
                if ($this->mconf['IFSUB'])      {
                        $IFSUBinit = 0; // Flag: If $IFSUB is generated
                        reset($NOconf);
                        while (list($key,$val)=each($NOconf))   {
                                if ($this->isItemState('IFSUB',$key))   {
                                        if (!$IFSUBinit)        {       // if this is the first IFSUB element, we must generate IFSUB.
                                                $IFSUBconf = $this->tmpl->splitConfArray($this->mconf['IFSUB.'],$splitCount);
                                                if ($this->mconf['IFSUBRO'])    {
                                                        $IFSUBROconf = $this->tmpl->splitConfArray($this->mconf['IFSUBRO.'],$splitCount);
                                                }
                                                $IFSUBinit = 1;
                                        }
                                        $NOconf[$key] = $IFSUBconf[$key];               // Substitute normal with ifsub
                                        if ($ROconf)    {       // If rollOver on normal, we must apply a state for rollOver on the active
                                                $ROconf[$key] = $IFSUBROconf[$key] ? $IFSUBROconf[$key] : $IFSUBconf[$key];             // If RollOver on active then apply this
                                        }
                                }
                        }
                }
                        // Prepare active settings, overriding normal settings
                if ($this->mconf['ACT'])        {
                        $ACTinit = 0;   // Flag: If $ACT is generated
                        reset($NOconf);
                        while (list($key,$val)=each($NOconf))   {       // Find active
                                if ($this->isItemState('ACT',$key))     {
                                        if (!$ACTinit)  {       // if this is the first 'active', we must generate ACT.
                                                $ACTconf = $this->tmpl->splitConfArray($this->mconf['ACT.'],$splitCount);
                                                        // Prepare active rollOver settings, overriding normal active settings
                                                if ($this->mconf['ACTRO'])      {
                                                        $ACTROconf = $this->tmpl->splitConfArray($this->mconf['ACTRO.'],$splitCount);
                                                }
                                                $ACTinit = 1;
                                        }
                                        $NOconf[$key] = $ACTconf[$key];         // Substitute normal with active
                                        if ($ROconf)    {       // If rollOver on normal, we must apply a state for rollOver on the active
                                                $ROconf[$key] = $ACTROconf[$key] ? $ACTROconf[$key] : $ACTconf[$key];           // If RollOver on active then apply this
                                        }
                                }
                        }
                }
                        // Prepare ACT (active)/IFSUB settings, overriding normal settings
                        // ACTIFSUB is true if there exist submenu items to the current item and the current item is active
                if ($this->mconf['ACTIFSUB'])   {
                        $ACTIFSUBinit = 0;      // Flag: If $ACTIFSUB is generated
                        reset($NOconf);
                        while (list($key,$val)=each($NOconf))   {       // Find active
                                if ($this->isItemState('ACTIFSUB',$key))        {
                                        if (!$ACTIFSUBinit)     {       // if this is the first 'active', we must generate ACTIFSUB.
                                                $ACTIFSUBconf = $this->tmpl->splitConfArray($this->mconf['ACTIFSUB.'],$splitCount);
                                                        // Prepare active rollOver settings, overriding normal active settings
                                                if ($this->mconf['ACTIFSUBRO']) {
                                                        $ACTIFSUBROconf = $this->tmpl->splitConfArray($this->mconf['ACTIFSUBRO.'],$splitCount);
                                                }
                                                $ACTIFSUBinit = 1;
                                        }
                                        $NOconf[$key] = $ACTIFSUBconf[$key];            // Substitute normal with active
                                        if ($ROconf)    {       // If rollOver on normal, we must apply a state for rollOver on the active
                                                $ROconf[$key] = $ACTIFSUBROconf[$key] ? $ACTIFSUBROconf[$key] : $ACTIFSUBconf[$key];            // If RollOver on active then apply this
                                        }
                                }
                        }
                }
                        // Prepare CUR (current) settings, overriding normal settings
                        // CUR is true if the current page equals the item here!
                if ($this->mconf['CUR'])        {
                        $CURinit = 0;   // Flag: If $CUR is generated
                        reset($NOconf);
                        while (list($key,$val)=each($NOconf))   {
                                if ($this->isItemState('CUR',$key))     {
                                        if (!$CURinit)  {       // if this is the first 'current', we must generate CUR. Basically this control is just inherited from the other implementations as current would only exist one time and thats it (unless you use special-features of HMENU)
                                                $CURconf = $this->tmpl->splitConfArray($this->mconf['CUR.'],$splitCount);
                                                if ($this->mconf['CURRO'])      {
                                                        $CURROconf = $this->tmpl->splitConfArray($this->mconf['CURRO.'],$splitCount);
                                                }
                                                $CURinit = 1;
                                        }
                                        $NOconf[$key] = $CURconf[$key];         // Substitute normal with current
                                        if ($ROconf)    {       // If rollOver on normal, we must apply a state for rollOver on the active
                                                $ROconf[$key] = $CURROconf[$key] ? $CURROconf[$key] : $CURconf[$key];           // If RollOver on active then apply this
                                        }
                                }
                        }
                }
                        // Prepare CUR (current)/IFSUB settings, overriding normal settings
                        // CURIFSUB is true if there exist submenu items to the current item and the current page equals the item here!
                if ($this->mconf['CURIFSUB'])   {
                        $CURIFSUBinit = 0;      // Flag: If $CURIFSUB is generated
                        reset($NOconf);
                        while (list($key,$val)=each($NOconf))   {
                                if ($this->isItemState('CURIFSUB',$key))        {
                                        if (!$CURIFSUBinit)     {       // if this is the first 'current', we must generate CURIFSUB.
                                                $CURIFSUBconf = $this->tmpl->splitConfArray($this->mconf['CURIFSUB.'],$splitCount);
                                                        // Prepare current rollOver settings, overriding normal current settings
                                                if ($this->mconf['CURIFSUBRO']) {
                                                        $CURIFSUBROconf = $this->tmpl->splitConfArray($this->mconf['CURIFSUBRO.'],$splitCount);
                                                }
                                                $CURIFSUBinit = 1;
                                        }
                                        $NOconf[$key] = $CURIFSUBconf[$key];            // Substitute normal with active
                                        if ($ROconf)    {       // If rollOver on normal, we must apply a state for rollOver on the current
                                                $ROconf[$key] = $CURIFSUBROconf[$key] ? $CURIFSUBROconf[$key] : $CURIFSUBconf[$key];            // If RollOver on current then apply this
                                        }
                                }
                        }
                }
                        // Prepare active settings, overriding normal settings
                if ($this->mconf['USR'])        {
                        $USRinit = 0;   // Flag: If $USR is generated
                        reset($NOconf);
                        while (list($key,$val)=each($NOconf))   {       // Find active
                                if ($this->isItemState('USR',$key))     {
                                        if (!$USRinit)  {       // if this is the first active, we must generate USR.
                                                $USRconf = $this->tmpl->splitConfArray($this->mconf['USR.'],$splitCount);
                                                        // Prepare active rollOver settings, overriding normal active settings
                                                if ($this->mconf['USRRO'])      {
                                                        $USRROconf = $this->tmpl->splitConfArray($this->mconf['USRRO.'],$splitCount);
                                                }
                                                $USRinit = 1;
                                        }
                                        $NOconf[$key] = $USRconf[$key];         // Substitute normal with active
                                        if ($ROconf)    {       // If rollOver on normal, we must apply a state for rollOver on the active
                                                $ROconf[$key] = $USRROconf[$key] ? $USRROconf[$key] : $USRconf[$key];           // If RollOver on active then apply this
                                        }
                                }
                        }
                }
                        // Prepare spacer settings, overriding normal settings
                if ($this->mconf['SPC'])        {
                        $SPCinit = 0;   // Flag: If $SPC is generated
                        reset($NOconf);
                        while (list($key,$val)=each($NOconf))   {       // Find spacers
                                if ($this->isItemState('SPC',$key))     {
                                        if (!$SPCinit)  {       // if this is the first spacer, we must generate SPC.
                                                $SPCconf = $this->tmpl->splitConfArray($this->mconf['SPC.'],$splitCount);
                                                $SPCinit = 1;
                                        }
                                        $NOconf[$key] = $SPCconf[$key];         // Substitute normal with spacer
                                }
                        }
                }
                        // Prepare Userdefined settings
                if ($this->mconf['USERDEF1'])   {
                        $USERDEF1init = 0;      // Flag: If $USERDEF1 is generated
                        reset($NOconf);
                        while (list($key,$val)=each($NOconf))   {       // Find active
                                if ($this->isItemState('USERDEF1',$key))        {
                                        if (!$USERDEF1init)     {       // if this is the first active, we must generate USERDEF1.
                                                $USERDEF1conf = $this->tmpl->splitConfArray($this->mconf['USERDEF1.'],$splitCount);
                                                        // Prepare active rollOver settings, overriding normal active settings
                                                if ($this->mconf['USERDEF1RO']) {
                                                        $USERDEF1ROconf = $this->tmpl->splitConfArray($this->mconf['USERDEF1RO.'],$splitCount);
                                                }
                                                $USERDEF1init = 1;
                                        }
                                        $NOconf[$key] = $USERDEF1conf[$key];            // Substitute normal with active
                                        if ($ROconf)    {       // If rollOver on normal, we must apply a state for rollOver on the active
                                                $ROconf[$key] = $USERDEF1ROconf[$key] ? $USERDEF1ROconf[$key] : $USERDEF1conf[$key];            // If RollOver on active then apply this
                                        }
                                }
                        }
                }
                        // Prepare Userdefined settings
                if ($this->mconf['USERDEF2'])   {
                        $USERDEF2init = 0;      // Flag: If $USERDEF2 is generated
                        reset($NOconf);
                        while (list($key,$val)=each($NOconf))   {       // Find active
                                if ($this->isItemState('USERDEF2',$key))        {
                                        if (!$USERDEF2init)     {       // if this is the first active, we must generate USERDEF2.
                                                $USERDEF2conf = $this->tmpl->splitConfArray($this->mconf['USERDEF2.'],$splitCount);
                                                        // Prepare active rollOver settings, overriding normal active settings
                                                if ($this->mconf['USERDEF2RO']) {
                                                        $USERDEF2ROconf = $this->tmpl->splitConfArray($this->mconf['USERDEF2RO.'],$splitCount);
                                                }
                                                $USERDEF2init = 1;
                                        }
                                        $NOconf[$key] = $USERDEF2conf[$key];            // Substitute normal with active
                                        if ($ROconf)    {       // If rollOver on normal, we must apply a state for rollOver on the active
                                                $ROconf[$key] = $USERDEF2ROconf[$key] ? $USERDEF2ROconf[$key] : $USERDEF2conf[$key];            // If RollOver on active then apply this
                                        }
                                }
                        }
                }

                return array($NOconf,$ROconf);
        }

        function link($key,$altTarget='',$typeOverride='') {

                        // Mount points:
                $MP_var = $this->getMPvar($key);
                $MP_params = $MP_var ? '&MP='.rawurlencode($MP_var) : '';

                        // Setting override ID
                if ($this->mconf['overrideId'] || $this->menuArr[$key]['overrideId'])   {
                        $overrideArray = array();
                                // If a user script returned the value overrideId in the menu array we use that as page id
                        $overrideArray['uid'] = $this->mconf['overrideId']?$this->mconf['overrideId']:$this->menuArr[$key]['overrideId'];
                        $overrideArray['alias'] = '';
                        $MP_params = '';        // clear MP parameters since ID was changed.
                } else {
                        $overrideArray='';
                }

                        // Setting main target:
                $mainTarget = $altTarget ? $altTarget : $this->mconf['target'];

                        // Creating link:
                if ($this->mconf['collapse'] && $this->isActive($this->menuArr[$key]['uid'], $this->getMPvar($key)))    {
                        $thePage = $this->sys_page->getPage($this->menuArr[$key]['pid']);
                        $LD = $this->tmpl->linkData($thePage,$mainTarget,'','',$overrideArray, $this->mconf['addParams'].$MP_params.$this->menuArr[$key]['_ADD_GETVARS'], $typeOverride);
                } else {
                        $LD = $this->tmpl->linkData($this->menuArr[$key],$mainTarget,'','',$overrideArray, $this->mconf['addParams'].$MP_params.$this->menuArr[$key]['_ADD_GETVARS'], $typeOverride);
                }

                        // Manipulation in case of access restricted pages:
                $this->changeLinksForAccessRestrictedPages($LD,$this->menuArr[$key],$mainTarget,$typeOverride);

                        // Overriding URL / Target if set to do so:
                if ($this->menuArr[$key]['_OVERRIDE_HREF'])     {
                        $LD['totalURL'] = $this->menuArr[$key]['_OVERRIDE_HREF'];
                        if ($this->menuArr[$key]['_OVERRIDE_TARGET'])   $LD['target'] = $this->menuArr[$key]['_OVERRIDE_TARGET'];
                }

                        // OnClick open in windows.
                $onClick='';
                if ($this->mconf['JSWindow'])   {
                        $conf=$this->mconf['JSWindow.'];
                        $url=$LD['totalURL'];
                        $LD['totalURL'] = '#';
                        $onClick= 'openPic(\''.$GLOBALS['TSFE']->baseUrlWrap($url).'\',\''.($conf['newWindow']?md5($url):'theNewPage').'\',\''.$conf['params'].'\'); return false;';
                        $GLOBALS['TSFE']->setJS('openPic');
                }

                        // out:
                $list = array();
                $list['HREF'] = strlen($LD['totalURL']) ? $LD['totalURL'] : $GLOBALS['TSFE']->baseUrl;  // Added this check: What it does is to enter the baseUrl (if set, which it should for "realurl" based sites) as URL if the calculated value is empty. The problem is that no link is generated with a blank URL and blank URLs might appear when the realurl encoding is used and a link to the frontpage is generated.
                $list['TARGET'] = $LD['target'];
                $list['onClick'] = $onClick;

                return $list;
        }

        function changeLinksForAccessRestrictedPages(&$LD, $page, $mainTarget, $typeOverride)   {

                        // If access restricted pages should be shown in menus, change the link of such pages to link to a redirection page:
                if ($this->mconf['showAccessRestrictedPages'] && $this->mconf['showAccessRestrictedPages']!=='NONE' && !$GLOBALS['TSFE']->checkPageGroupAccess($page))          {
                        $thePage = $this->sys_page->getPage($this->mconf['showAccessRestrictedPages']);

                        $addParams = $this->mconf['showAccessRestrictedPages.']['addParams'];
                        $addParams = str_replace('###RETURN_URL###',rawurlencode($LD['totalURL']),$addParams);
                        $addParams = str_replace('###PAGE_ID###',$page['uid'],$addParams);
                        $LD = $this->tmpl->linkData($thePage,$mainTarget,'','','', $addParams, $typeOverride);
                }
        }

        function subMenu($uid, $objSuffix='')   {

                        // Setting alternative menu item array if _SUB_MENU has been defined in the current ->menuArr
                $altArray = '';
                if (is_array($this->menuArr[$this->I['key']]['_SUB_MENU']) && count($this->menuArr[$this->I['key']]['_SUB_MENU']))      {
                        $altArray = $this->menuArr[$this->I['key']]['_SUB_MENU'];
                }

                        // Make submenu if the page is the next active
                $cls = strtolower($this->conf[($this->menuNumber+1).$objSuffix]);
                $subLevelClass = ($cls && t3lib_div::inList($this->tmpl->menuclasses,$cls)) ? $cls : '';

                if ($subLevelClass && ($this->mconf['expAll'] || $this->isNext($uid, $this->getMPvar($this->I['key'])) || is_array($altArray)) && !$this->mconf['sectionIndex'])        {
                        $submenu = t3lib_div::makeInstance('tslib_'.$subLevelClass);
                        $submenu->entryLevel = $this->entryLevel+1;
                        $submenu->rL_uidRegister = $this->rL_uidRegister;
                        $submenu->MP_array = $this->MP_array;
                        if ($this->menuArr[$this->I['key']]['_MP_PARAM'])       {
                                $submenu->MP_array[] = $this->menuArr[$this->I['key']]['_MP_PARAM'];
                        }

                                // especially scripts that build the submenu needs the parent data
                        $submenu->parentMenuArr = $this->menuArr;

                                // Setting alternativeMenuTempArray (will be effective only if an array)
                        if (is_array($altArray))        {
                                $submenu->alternativeMenuTempArray = $altArray;
                        }

                        if ($submenu->start($this->tmpl, $this->sys_page, $uid, $this->conf, $this->menuNumber+1, $objSuffix))  {
                                $submenu->makeMenu();
                                return $submenu->writeMenu();
                        }
                }
        }

        function isNext($uid, $MPvar='')        {

                        // Check for always active PIDs:
                if (count($this->alwaysActivePIDlist) && in_array($uid,$this->alwaysActivePIDlist))     {
                        return TRUE;
                }

                $testUid = $uid.($MPvar?':'.$MPvar:'');
                if ($uid && $testUid==$this->nextActive)        {
                        return TRUE;
                }
        }

        function isActive($uid, $MPvar='')      {

                        // Check for always active PIDs:
                if (count($this->alwaysActivePIDlist) && in_array($uid,$this->alwaysActivePIDlist))     {
                        return TRUE;
                }

                $testUid = $uid.($MPvar?':'.$MPvar:'');
                if ($uid && in_array('ITEM:'.$testUid, $this->rL_uidRegister))  {
                        return TRUE;
                }
        }

        function isCurrent($uid, $MPvar='')     {
                $testUid = $uid.($MPvar?':'.$MPvar:'');
                if ($uid && !strcmp(end($this->rL_uidRegister),'ITEM:'.$testUid))       {
                        return TRUE;
                }
        }

        function isSubMenu($uid)        {

                        // Looking for a mount-pid for this UID since if that exists we should look for a subpages THERE and not in the input $uid;
                $mount_info = $this->sys_page->getMountPointInfo($uid);
                if (is_array($mount_info))      {
                        $uid = $mount_info['mount_pid'];
                }

                $recs = $this->sys_page->getMenu($uid,'uid,pid,doktype,mount_pid,mount_pid_ol,nav_hide');
                foreach($recs as $theRec)       {
                        if (!t3lib_div::inList($this->doktypeExcludeList,$theRec['doktype']) && (!$theRec['nav_hide'] || $this->conf['includeNotInMenu']))      {       // If a menu item seems to be another type than 'Not in menu', then return true (there were items!)
                                return TRUE;
                        }
                }
        }

        function isItemState($kind,$key)        {
                $natVal=0;
                if ($this->menuArr[$key]['ITEM_STATE']) {               // If any value is set for ITEM_STATE the normal evaluation is discarded
                        if (!strcmp($this->menuArr[$key]['ITEM_STATE'],$kind))  {$natVal=1;}
                } else {
                        switch($kind)   {
                                case 'SPC':
                                        $natVal = $this->menuArr[$key]['isSpacer'];
                                break;
                                case 'IFSUB':
                                        $natVal = $this->isSubMenu($this->menuArr[$key]['uid']);
                                break;
                                case 'ACT':
                                        $natVal = $this->isActive($this->menuArr[$key]['uid'], $this->getMPvar($key));
                                break;
                                case 'ACTIFSUB':
                                        $natVal = $this->isActive($this->menuArr[$key]['uid'], $this->getMPvar($key)) && $this->isSubMenu($this->menuArr[$key]['uid']);
                                break;
                                case 'CUR':
                                        $natVal = $this->isCurrent($this->menuArr[$key]['uid'], $this->getMPvar($key));
                                break;
                                case 'CURIFSUB':
                                        $natVal = $this->isCurrent($this->menuArr[$key]['uid'], $this->getMPvar($key)) && $this->isSubMenu($this->menuArr[$key]['uid']);
                                break;
                                case 'USR':
                                        $natVal = $this->menuArr[$key]['fe_group'];
                                break;
                        }
                }

                return $natVal;
        }

        function accessKey($title)      {
                        // The global array ACCESSKEY is used to globally control if letters are already used!!
                $result = Array();

                $titleLen = strlen($title);
                for ($a=0;$a<$titleLen;$a++)    {
                        $key = strtoupper(trim(substr($title,$a,1)));
                        if (preg_match('/[a-zA-Z]/', $key) && !isset($GLOBALS['TSFE']->accessKey[$key]))        {
                                $GLOBALS['TSFE']->accessKey[$key]=1;
                                $result['code'] = ' accesskey="'.$key.'"';
                                $result['alt'] = ' (ALT+'.$key.')';
                                break;
                        }
                }
                return $result;
        }

        function userProcess($mConfKey,$passVar)        {
                if ($this->mconf[$mConfKey])    {
                        $funcConf = $this->mconf[$mConfKey.'.'];
                        $funcConf['parentObj']=&$this;
                        $passVar = $GLOBALS['TSFE']->cObj->callUserFunction($this->mconf[$mConfKey], $funcConf, $passVar);
                }
                return $passVar;
        }

        function setATagParts() {
                $this->I['A1'] = '<a '.t3lib_div::implodeAttributes($this->I['linkHREF'],1).$this->I['val']['ATagParams'].$this->I['addATagParams'].$this->I['accessKey']['code'].'>';
                $this->I['A2'] = '</a>';
        }

        function getPageTitle($title,$nav_title)        {
                return strcmp(trim($nav_title),'') ? $nav_title : $title;
        }

        function getMPvar($key) {
                if ($GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids'])     {
                        $localMP_array = $this->MP_array;
                        if ($this->menuArr[$key]['_MP_PARAM'])  $localMP_array[] = $this->menuArr[$key]['_MP_PARAM'];   // NOTICE: "_MP_PARAM" is allowed to be a commalist of PID pairs!
                        $MP_params = count($localMP_array) ? implode(',',$localMP_array) : '';
                        return $MP_params;
                }
        }

        function getDoktypeExcludeWhere() {
                return $this->doktypeExcludeList ? ' AND pages.doktype NOT IN ('.$this->doktypeExcludeList.')' : '';
        }

        function getBannedUids() {
                $banUidArray = array();

                if (trim($this->conf['excludeUidList']))        {
                        $banUidList = str_replace('current', $GLOBALS['TSFE']->page['uid'], $this->conf['excludeUidList']);
                        $banUidArray = t3lib_div::intExplode(',', $banUidList);
                }

                return $banUidArray;
        }

}



















class tslib_tmenu extends tslib_menu {

        function generate()     {
                $splitCount = count($this->menuArr);
                if ($splitCount)        {
                        list($NOconf) = $this->procesItemStates($splitCount);
                }
                if ($this->mconf['debugItemConf'])      {echo '<h3>$NOconf:</h3>';      debug($NOconf); }
                $this->result = $NOconf;
        }

        function writeMenu()    {
                if (is_array($this->result) && count($this->result))    {
                        $this->WMcObj =t3lib_div::makeInstance('tslib_cObj');   // Create new tslib_cObj for our use
                        $this->WMresult='';
                        $this->INPfixMD5 = substr(md5(microtime().'tmenu'),0,4);
                        $this->WMmenuItems = count($this->result);

                        $this->WMsubmenuObjSuffixes = $this->tmpl->splitConfArray(array('sOSuffix'=>$this->mconf['submenuObjSuffixes']),$this->WMmenuItems);

                        $this->extProc_init();
                        reset($this->result);
                        while (list($key,$val)=each($this->result))     {
                                $GLOBALS['TSFE']->register['count_HMENU_MENUOBJ']++;
                                $GLOBALS['TSFE']->register['count_MENUOBJ']++;

                                $this->I=array();
                                $this->WMcObj->start($this->menuArr[$key],'pages');             // Initialize the cObj with the page record of the menu item
                                $this->I['key'] = $key;
                                $this->I['INPfix']= $this->imgNameNotRandom?'':'_'.$this->INPfixMD5.'_'.$key;
                                $this->I['val'] = $val;
                                $this->I['title'] = $this->WMcObj->stdWrap($this->getPageTitle($this->menuArr[$key]['title'],$this->menuArr[$key]['nav_title']),$this->I['val']['stdWrap.']);
                                $this->I['uid'] = $this->menuArr[$key]['uid'];
                                $this->I['mount_pid'] = $this->menuArr[$key]['mount_pid'];
                                $this->I['pid'] = $this->menuArr[$key]['pid'];
                                $this->I['spacer'] = $this->menuArr[$key]['isSpacer'];

                                        // Make link tag
                                $this->I['val']['ATagParams'] = $this->WMcObj->getATagParams($this->I['val'], 0);
                                $this->I['linkHREF'] =  $this->link($key,$this->I['val']['altTarget'],$this->mconf['forceTypeValue']);

                                        // Title attribute of links:
                                $titleAttrValue = $this->WMcObj->stdWrap($this->I['val']['ATagTitle'],$this->I['val']['ATagTitle.']);
                                if (strlen($titleAttrValue))    {
                                        $this->I['linkHREF']['title'] = $titleAttrValue;
                                }

                                        // Setting "blurlink()" function:
                                if (!$this->mconf['noBlur'])    {
                                        $this->I['linkHREF']['onFocus']='blurLink(this);';
                                }

                                        // Make link:
                                if ($this->I['val']['RO'])      {
                                        $this->I['theName'] = $this->imgNamePrefix.$this->I['uid'].$this->I['INPfix'];
                                        $over='';
                                        $out ='';
                                        if ($this->I['val']['beforeROImg'])     {
                                                $over.= $this->WMfreezePrefix."over('".$this->I['theName']."before');";
                                                $out.= $this->WMfreezePrefix."out('".$this->I['theName']."before');";
                                        }
                                        if ($this->I['val']['afterROImg'])      {
                                                $over.= $this->WMfreezePrefix."over('".$this->I['theName']."after');";
                                                $out.= $this->WMfreezePrefix."out('".$this->I['theName']."after');";
                                        }
                                        $this->I['linkHREF']['onMouseover']=$over;
                                        $this->I['linkHREF']['onMouseout']=$out;
                                        if ($over || $out)      $GLOBALS['TSFE']->setJS('mouseOver');

                                                // Change background color:
                                        if ($this->I['val']['RO_chBgColor'])    {
                                                $this->addJScolorShiftFunction();
                                                $chBgP = t3lib_div::trimExplode('|',$this->I['val']['RO_chBgColor']);
                                                $this->I['linkHREF']['onMouseover'].="changeBGcolor('".$chBgP[2].$this->I['uid']."','".$chBgP[0]."');";
                                                $this->I['linkHREF']['onMouseout'].="changeBGcolor('".$chBgP[2].$this->I['uid']."','".$chBgP[1]."');";
                                        }

                                        $this->extProc_RO($key);
                                }


                                        // Calling extra processing function
                                $this->extProc_beforeLinking($key);

                                        // Compile link tag
                                if (!$this->I['val']['doNotLinkIt']) {$this->I['val']['doNotLinkIt']=0;}
                                if (!$this->I['spacer'] && $this->I['val']['doNotLinkIt']!=1)   {
                                        $this->setATagParts();
                                } else {
                                        $this->I['A1'] = '';
                                        $this->I['A2'] = '';
                                }

                                        // ATAGBeforeWrap processing:
                                if ($this->I['val']['ATagBeforeWrap'])  {
                                        $wrapPartsBefore = explode('|',$this->I['val']['linkWrap']);
                                        $wrapPartsAfter = array('','');
                                } else {
                                        $wrapPartsBefore = array('','');
                                        $wrapPartsAfter = explode('|',$this->I['val']['linkWrap']);
                                }
                                if ($this->I['val']['stdWrap2'] || isset($this->I['val']['stdWrap2.'])) {
                                        $wrapPartsStdWrap = explode($this->I['val']['stdWrap2']?$this->I['val']['stdWrap2']:'|',$this->WMcObj->stdWrap('|',$this->I['val']['stdWrap2.']));
                                } else {$wrapPartsStdWrap = array('','');}

                                        // Make before, middle and after parts
                                $this->I['parts'] = array();
                                $this->I['parts']['before']=$this->getBeforeAfter('before');
                                $this->I['parts']['stdWrap2_begin']=$wrapPartsStdWrap[0];
                                if (!$this->I['val']['doNotShowLink']) {
                                        $this->I['parts']['notATagBeforeWrap_begin'] = $wrapPartsAfter[0];
                                        $this->I['parts']['ATag_begin'] = $this->I['A1'];
                                        $this->I['parts']['ATagBeforeWrap_begin'] = $wrapPartsBefore[0];
                                        $this->I['parts']['title'] = $this->I['title'];
                                        $this->I['parts']['ATagBeforeWrap_end'] = $wrapPartsBefore[1];
                                        $this->I['parts']['ATag_end'] = $this->I['A2'];
                                        $this->I['parts']['notATagBeforeWrap_end'] = $wrapPartsAfter[1];
                                }
                                $this->I['parts']['stdWrap2_end']=$wrapPartsStdWrap[1];
                                $this->I['parts']['after']=$this->getBeforeAfter('after');

                                        // Passing I to a user function
                                if ($this->mconf['IProcFunc'])  {
                                        $this->I = $this->userProcess('IProcFunc',$this->I);
                                }

                                        // Merge parts + beforeAllWrap
                                $this->I['theItem']= implode('',$this->I['parts']);
                                $this->I['theItem']= $this->extProc_beforeAllWrap($this->I['theItem'],$key);

                                        // allWrap:
                                $allWrap = $this->WMcObj->stdWrap($this->I['val']['allWrap'],$this->I['val']['allWrap.']);
                                $this->I['theItem'] = $this->tmpl->wrap($this->I['theItem'],$allWrap);

                                if ($this->I['val']['subst_elementUid'])        $this->I['theItem'] = str_replace('{elementUid}',$this->I['uid'],$this->I['theItem']);

                                        // allStdWrap:
                                if (is_array($this->I['val']['allStdWrap.']))   {
                                        $this->I['theItem'] = $this->WMcObj->stdWrap($this->I['theItem'],$this->I['val']['allStdWrap.']);
                                }

                                        // Calling extra processing function
                                $this->extProc_afterLinking($key);
                        }
                        return $this->extProc_finish();
                }
        }

        function getBeforeAfter($pref)  {
                $res = '';
                if ($imgInfo = $this->WMcObj->getImgResource($this->I['val'][$pref.'Img'],$this->I['val'][$pref.'Img.']))       {
                        $imgInfo[3] = t3lib_div::png_to_gif_by_imagemagick($imgInfo[3]);
                        if ($this->I['val']['RO'] && $this->I['val'][$pref.'ROImg'] && !$this->I['spacer'])     {
                                $imgROInfo = $this->WMcObj->getImgResource($this->I['val'][$pref.'ROImg'],$this->I['val'][$pref.'ROImg.']);
                                $imgROInfo[3] = t3lib_div::png_to_gif_by_imagemagick($imgROInfo[3]);
                                if ($imgROInfo) {
                                        $theName = $this->imgNamePrefix.$this->I['uid'].$this->I['INPfix'].$pref;
                                        $name = ' '.$this->nameAttribute.'="'.$theName.'"';
                                        $GLOBALS['TSFE']->JSImgCode.= chr(10).$theName.'_n=new Image(); '.$theName.'_n.src = "'.$GLOBALS['TSFE']->absRefPrefix.$imgInfo[3].'"; ';
                                        $GLOBALS['TSFE']->JSImgCode.= chr(10).$theName.'_h=new Image(); '.$theName.'_h.src = "'.$GLOBALS['TSFE']->absRefPrefix.$imgROInfo[3].'"; ';
                                }
                        }
                        $GLOBALS['TSFE']->imagesOnPage[]=$imgInfo[3];
                        $res='<img src="'.$GLOBALS['TSFE']->absRefPrefix.$imgInfo[3].'" width="'.$imgInfo[0].'" height="'.$imgInfo[1].'"'.$name.($this->I['val'][$pref.'ImgTagParams']?" ".$this->I['val'][$pref.'ImgTagParams']:'').tslib_cObj::getBorderAttr('border="0"');
                        if (!strstr($res,'alt="'))      $res.=' alt=""';        // Adding alt attribute if not set.
                        $res.=' />';
                        if ($this->I['val'][$pref.'ImgLink'])   {$res=$this->I['A1'].$res.$this->I['A2'];}
                }
                return $this->tmpl->wrap($res.$this->WMcObj->stdWrap($this->I['val'][$pref],$this->I['val'][$pref.'.']), $this->I['val'][$pref.'Wrap']);
        }

        function addJScolorShiftFunction()      {
                $GLOBALS['TSFE']->additionalJavaScript['TMENU:changeBGcolor()']='
                        function changeBGcolor(id,color) {      //
                                if (document.getElementById && document.getElementById(id))     {
                                        document.getElementById(id).style.background = color;
                                        return true;
                                } else if (document.layers && document.layers[id]) {
                                document.layers[id].bgColor = color;
                                        return true;
                            }
                        }
                ';
        }

        function extProc_init() {
        }

        function extProc_RO($key)       {
        }

        function extProc_beforeLinking($key)    {
        }

        function extProc_afterLinking($key)     {
                        // Add part to the accumulated result + fetch submenus
                if (!$this->I['spacer'])        {
                        $this->I['theItem'].= $this->subMenu($this->I['uid'], $this->WMsubmenuObjSuffixes[$key]['sOSuffix']);
                }
                $this->WMresult.= $this->I['val']['wrapItemAndSub'] ? $this->tmpl->wrap($this->I['theItem'],$this->I['val']['wrapItemAndSub']) : $this->I['theItem'];
        }

        function extProc_beforeAllWrap($item,$key)      {
                return $item;
        }

        function extProc_finish()       {
                return $this->tmpl->wrap($this->WMresult,$this->mconf['wrap']).$this->WMextraScript;
        }
}
























class tslib_gmenu extends tslib_menu {

        function generate()     {
                $splitCount = count($this->menuArr);
                if ($splitCount)        {
                        list($NOconf,$ROconf) = $this->procesItemStates($splitCount);

                                //store initial count value
                        $temp_HMENU_MENUOBJ = $GLOBALS['TSFE']->register['count_HMENU_MENUOBJ'];
                        $temp_MENUOBJ = $GLOBALS['TSFE']->register['count_MENUOBJ'];
                                // Now we generate the giffiles:
                        $this->makeGifs($NOconf,'NO');
                                // store count from NO obj
                        $tempcnt_HMENU_MENUOBJ = $GLOBALS['TSFE']->register['count_HMENU_MENUOBJ'];
                        $tempcnt_MENUOBJ = $GLOBALS['TSFE']->register['count_MENUOBJ'];

                        if ($this->mconf['debugItemConf'])      {echo '<h3>$NOconf:</h3>';      debug($NOconf); }
                        if ($ROconf)    {               // RollOver
                                        //start recount for rollover with initial values
                                $GLOBALS['TSFE']->register['count_HMENU_MENUOBJ']= $temp_HMENU_MENUOBJ;
                                $GLOBALS['TSFE']->register['count_MENUOBJ']= $temp_MENUOBJ;
                                $this->makeGifs($ROconf,'RO');
                                if ($this->mconf['debugItemConf'])      {echo '<h3>$ROconf:</h3>';      debug($ROconf); }
                        }
                                // use count from NO obj
                        $GLOBALS['TSFE']->register['count_HMENU_MENUOBJ'] = $tempcnt_HMENU_MENUOBJ;
                        $GLOBALS['TSFE']->register['count_MENUOBJ'] = $tempcnt_MENUOBJ;
                }
        }

        function makeGifs($conf, $resKey)       {
                $isGD = $GLOBALS['TYPO3_CONF_VARS']['GFX']['gdlib'];

                if (!is_array($conf)) {
                        $conf = Array();
                }

                $totalWH=array();
                $items = count($conf);
                if ($isGD)      {
                                // generate the gif-files. the $menuArr is filled with some values like output_w, output_h, output_file
                        $Hcounter = 0;
                        $Wcounter = 0;
                        $Hobjs = $this->mconf['applyTotalH'];
                        if ($Hobjs)     {$Hobjs = t3lib_div::intExplode(',',$Hobjs);}
                        $Wobjs = $this->mconf['applyTotalW'];
                        if ($Wobjs)     {$Wobjs = t3lib_div::intExplode(',',$Wobjs);}
                        $minDim = $this->mconf['min'];
                        if ($minDim) {$minDim = tslib_cObj::calcIntExplode(',',$minDim.',');}
                        $maxDim = $this->mconf['max'];
                        if ($maxDim) {$maxDim = tslib_cObj::calcIntExplode(',',$maxDim.',');}

                        if ($minDim)    {
                                $conf[$items]=$conf[$items-1];
                                $this->menuArr[$items]=Array();
                                $items = count($conf);
                        }

                        // TOTAL width
                        if ($this->mconf['useLargestItemX'] || $this->mconf['useLargestItemY'] || $this->mconf['distributeX'] || $this->mconf['distributeY'])   {
                                $totalWH = $this->findLargestDims($conf,$items,$Hobjs,$Wobjs,$minDim,$maxDim);
                        }
                }

                $c=0;
                $maxFlag=0;
                $distributeAccu=array('H'=>0,'W'=>0);
                reset($conf);
                while (list($key,$val)=each($conf))     {
                        $GLOBALS['TSFE']->register['count_HMENU_MENUOBJ']++;
                        $GLOBALS['TSFE']->register['count_MENUOBJ']++;

                        if ($items==($c+1) && $minDim)  {
                                $Lobjs = $this->mconf['removeObjectsOfDummy'];
                                if ($Lobjs)     {
                                        $Lobjs = t3lib_div::intExplode(',',$Lobjs);
                                        reset($Lobjs);
                                        while(list(,$remItem)=each($Lobjs))     {
                                                unset($val[$remItem]);
                                                unset($val[$remItem.'.']);
                                        }
                                }

                                $flag =0;
                                $tempXY = explode(',',$val['XY']);
                                if ($Wcounter<$minDim[0])       {$tempXY[0]=$minDim[0]-$Wcounter; $flag=1;}
                                if ($Hcounter<$minDim[1])       {$tempXY[1]=$minDim[1]-$Hcounter; $flag=1;}
                                $val['XY'] = implode(',',$tempXY);
                                if (!$flag){break;}
                        }
                        $c++;


                        if ($isGD)      {
                                        // Pre-working the item
                                $gifCreator = t3lib_div::makeInstance('tslib_gifBuilder');
                                $gifCreator->init();
                                $gifCreator->start($val,$this->menuArr[$key]);

                                        // If useLargestItemH/W is specified
                                if (count($totalWH) && ($this->mconf['useLargestItemX'] || $this->mconf['useLargestItemY']))    {
                                        $tempXY = explode(',',$gifCreator->setup['XY']);
                                        if ($this->mconf['useLargestItemX'])    {$tempXY[0] = max($totalWH['W']);}
                                        if ($this->mconf['useLargestItemY'])    {$tempXY[1] = max($totalWH['H']);}
                                                // regenerate the new values...
                                        $val['XY'] = implode(',',$tempXY);
                                        $gifCreator = t3lib_div::makeInstance('tslib_gifBuilder');
                                        $gifCreator->init();
                                        $gifCreator->start($val,$this->menuArr[$key]);
                                }

                                        // If distributeH/W is specified
                                if (count($totalWH) && ($this->mconf['distributeX'] || $this->mconf['distributeY']))    {
                                        $tempXY = explode(',',$gifCreator->setup['XY']);

                                        if ($this->mconf['distributeX'])        {
                                                $diff = $this->mconf['distributeX']-$totalWH['W_total']-$distributeAccu['W'];
                                                $compensate = round($diff /($items-$c+1));
                                                $distributeAccu['W']+=$compensate;
                                                $tempXY[0] = $totalWH['W'][$key]+$compensate;
                                        }
                                        if ($this->mconf['distributeY'])        {
                                                $diff = $this->mconf['distributeY']-$totalWH['H_total']-$distributeAccu['H'];
                                                $compensate = round($diff /($items-$c+1));
                                                $distributeAccu['H']+=$compensate;
                                                $tempXY[1] = $totalWH['H'][$key]+$compensate;
                                        }
                                                // regenerate the new values...
                                        $val['XY'] = implode(',',$tempXY);
                                        $gifCreator = t3lib_div::makeInstance('tslib_gifBuilder');
                                        $gifCreator->init();
                                        $gifCreator->start($val,$this->menuArr[$key]);
                                }

                                        // If max dimensions are specified
                                if ($maxDim)    {
                                        $tempXY = explode(',',$val['XY']);
                                        if ($maxDim[0] && $Wcounter+$gifCreator->XY[0]>=$maxDim[0])     {$tempXY[0]==$maxDim[0]-$Wcounter; $maxFlag=1;}
                                        if ($maxDim[1] && $Hcounter+$gifCreator->XY[1]>=$maxDim[1])     {$tempXY[1]=$maxDim[1]-$Hcounter; $maxFlag=1;}
                                        if ($maxFlag)   {
                                                $val['XY'] = implode(',',$tempXY);
                                                $gifCreator = t3lib_div::makeInstance('tslib_gifBuilder');
                                                $gifCreator->init();
                                                $gifCreator->start($val,$this->menuArr[$key]);
                                        }
                                }




                                // displace
                                if ($Hobjs)     {
                                        reset($Hobjs);
                                        while(list(,$index)=each($Hobjs))       {
                                                if ($gifCreator->setup[$index] && $gifCreator->setup[$index.'.'])       {
                                                        $oldOffset = explode(',',$gifCreator->setup[$index.'.']['offset']);
                                                        $gifCreator->setup[$index.'.']['offset'] = implode(',',$gifCreator->applyOffset($oldOffset,Array(0,-$Hcounter)));
                                                }
                                        }
                                }

                                if ($Wobjs)     {
                                        reset($Wobjs);
                                        while(list(,$index)=each($Wobjs))       {
                                                if ($gifCreator->setup[$index] && $gifCreator->setup[$index.'.'])       {
                                                        $oldOffset = explode(',',$gifCreator->setup[$index.'.']['offset']);
                                                        $gifCreator->setup[$index.'.']['offset'] = implode(',',$gifCreator->applyOffset($oldOffset,Array(-$Wcounter,0)));
                                                }
                                        }
                                }
                        }

                                // Finding alternative GIF names if any (by altImgResource)
                        $gifFileName='';
                        if ($conf[$key]['altImgResource'] || is_array($conf[$key]['altImgResource.']))  {
                                if (!is_object($cObj)) {$cObj=t3lib_div::makeInstance('tslib_cObj');}
                                $cObj->start($this->menuArr[$key],'pages');
                                $altImgInfo = $cObj->getImgResource($conf[$key]['altImgResource'],$conf[$key]['altImgResource.']);
                                $gifFileName=$altImgInfo[3];
                        }

                                // If an alternative name was NOT given, find the GIFBUILDER name.
                        if (!$gifFileName && $isGD)     {
                                $gifCreator->createTempSubDir('menu/');
                                $gifFileName = $gifCreator->fileName('menu/');
                        }

                                // Generation of image file:
                        if (@file_exists($gifFileName)) {               // File exists
                                $info = @getimagesize($gifFileName);
                                $this->result[$resKey][$key]['output_w']=intval($info[0]);
                                $this->result[$resKey][$key]['output_h']=intval($info[1]);
                                $this->result[$resKey][$key]['output_file']=$gifFileName;
                        } elseif ($isGD) {              // file is generated
                                $gifCreator->make();
                                $this->result[$resKey][$key]['output_w']=$gifCreator->w;
                                $this->result[$resKey][$key]['output_h']=$gifCreator->h;
                                $this->result[$resKey][$key]['output_file'] = $gifFileName;
                                $gifCreator->output($this->result[$resKey][$key]['output_file']);
                                $gifCreator->destroy();
                        }
                        $this->result[$resKey][$key]['output_file'] = t3lib_div::png_to_gif_by_imagemagick($this->result[$resKey][$key]['output_file']);
                        $this->result[$resKey][$key]['noLink']=$conf[$key]['noLink'];
                        $this->result[$resKey][$key]['altTarget']=$conf[$key]['altTarget'];
                        $this->result[$resKey][$key]['imgParams']=$conf[$key]['imgParams'];
                        $this->result[$resKey][$key]['ATagTitle'] = $conf[$key]['ATagTitle'];
                        $this->result[$resKey][$key]['ATagTitle.'] = $conf[$key]['ATagTitle.'];
                        $this->result[$resKey][$key]['wrap'] = $conf[$key]['wrap'];
                        $this->result[$resKey][$key]['allWrap'] = $conf[$key]['allWrap'];
                        $this->result[$resKey][$key]['allWrap.'] = $conf[$key]['allWrap.'];
                        $this->result[$resKey][$key]['subst_elementUid'] = $conf[$key]['subst_elementUid'];
                        $this->result[$resKey][$key]['allStdWrap.'] = $conf[$key]['allStdWrap.'];

                        $Hcounter+=$this->result[$resKey][$key]['output_h'];            // counter is increased
                        $Wcounter+=$this->result[$resKey][$key]['output_w'];            // counter is increased

                        if ($maxFlag){break;}
                }
        }

        function findLargestDims($conf,$items,$Hobjs,$Wobjs,$minDim,$maxDim)    {
                $totalWH = array(
                        'W' => array(),
                        'H' => array(),
                        'W_total' => 0,
                        'H_total' => 0
                );

                $Hcounter = 0;
                $Wcounter = 0;
                $c=0;
                $maxFlag=0;
                reset($conf);
                while (list($key,$val)=each($conf))     {
                        // SAME CODE AS makeGifs()! BEGIN
                        if ($items==($c+1) && $minDim)  {
                                $Lobjs = $this->mconf['removeObjectsOfDummy'];
                                if ($Lobjs)     {
                                        $Lobjs = t3lib_div::intExplode(',',$Lobjs);
                                        reset($Lobjs);
                                        while(list(,$remItem)=each($Lobjs))     {
                                                unset($val[$remItem]);
                                                unset($val[$remItem.'.']);
                                        }
                                }

                                $flag =0;
                                $tempXY = explode(',',$val['XY']);
                                if ($Wcounter<$minDim[0])       {$tempXY[0]=$minDim[0]-$Wcounter; $flag=1;}
                                if ($Hcounter<$minDim[1])       {$tempXY[1]=$minDim[1]-$Hcounter; $flag=1;}
                                $val['XY'] = implode(',',$tempXY);
                                if (!$flag){break;}
                        }
                        $c++;

                        $gifCreator = t3lib_div::makeInstance('tslib_gifBuilder');
                        $gifCreator->init();
                        $gifCreator->start($val,$this->menuArr[$key]);
                        if ($maxDim)    {
                                $tempXY = explode(',',$val['XY']);
                                if ($maxDim[0] && $Wcounter+$gifCreator->XY[0]>=$maxDim[0])     {$tempXY[0]==$maxDim[0]-$Wcounter; $maxFlag=1;}
                                if ($maxDim[1] && $Hcounter+$gifCreator->XY[1]>=$maxDim[1])     {$tempXY[1]=$maxDim[1]-$Hcounter; $maxFlag=1;}
                                if ($maxFlag)   {
                                        $val['XY'] = implode(',',$tempXY);
                                        $gifCreator = t3lib_div::makeInstance('tslib_gifBuilder');
                                        $gifCreator->init();
                                        $gifCreator->start($val,$this->menuArr[$key]);
                                }
                        }
                        // SAME CODE AS makeGifs()! END

                                // Setting the width/height
                        $totalWH['W'][$key]=$gifCreator->XY[0];
                        $totalWH['H'][$key]=$gifCreator->XY[1];
                        $totalWH['W_total']+=$gifCreator->XY[0];
                        $totalWH['H_total']+=$gifCreator->XY[1];
                                // ---- //

                        $Hcounter+=$gifCreator->XY[1];          // counter is increased
                        $Wcounter+=$gifCreator->XY[0];          // counter is increased

                        if ($maxFlag){break;}
                }
                return $totalWH;
        }

        function writeMenu()    {
                if (is_array($this->menuArr) && is_array($this->result) && count($this->result) && is_array($this->result['NO']))       {
                        $this->WMcObj = t3lib_div::makeInstance('tslib_cObj');  // Create new tslib_cObj for our use
                        $this->WMresult='';
                        $this->INPfixMD5 = substr(md5(microtime().$this->GMENU_fixKey),0,4);
                        $this->WMmenuItems = count($this->result['NO']);

                        $this->WMsubmenuObjSuffixes = $this->tmpl->splitConfArray(array('sOSuffix'=>$this->mconf['submenuObjSuffixes']),$this->WMmenuItems);

                        $this->extProc_init();
                        for ($key=0;$key<$this->WMmenuItems;$key++)     {
                                if ($this->result['NO'][$key]['output_file'])   {
                                        $this->WMcObj->start($this->menuArr[$key],'pages');             // Initialize the cObj with the page record of the menu item

                                        $this->I =array();
                                        $this->I['key'] = $key;
                                        $this->I['INPfix']= $this->imgNameNotRandom?'':'_'.$this->INPfixMD5.'_'.$key;
                                        $this->I['val'] = $this->result['NO'][$key];
                                        $this->I['title'] = $this->getPageTitle($this->menuArr[$key]['title'],$this->menuArr[$key]['nav_title']);
                                        $this->I['uid'] = $this->menuArr[$key]['uid'];
                                        $this->I['mount_pid'] = $this->menuArr[$key]['mount_pid'];
                                        $this->I['pid'] = $this->menuArr[$key]['pid'];
                                        $this->I['spacer'] = $this->menuArr[$key]['isSpacer'];
                                        if (!$this->I['uid'] && !$this->menuArr[$key]['_OVERRIDE_HREF']) {$this->I['spacer']=1;}
                                        $this->I['noLink'] = ($this->I['spacer'] || $this->I['val']['noLink'] || !count($this->menuArr[$key]));         // !count($this->menuArr[$key]) means that this item is a dummyItem
                                        $this->I['name']='';

                                                // Set access key
                                        if ($this->mconf['accessKey'])  {
                                                $this->I['accessKey'] = $this->accessKey($this->I['title']);
                                        } else {
                                                $this->I['accessKey']=Array();
                                        }

                                                // Get link.
                                        $this->I['linkHREF'] = $this->link($key,$this->I['val']['altTarget'],$this->mconf['forceTypeValue']);
                                                // Title attribute of links:
                                        $titleAttrValue = $this->WMcObj->stdWrap($this->I['val']['ATagTitle'],$this->I['val']['ATagTitle.']).$this->I['accessKey']['alt'];
                                        if (strlen($titleAttrValue))    {
                                                $this->I['linkHREF']['title'] = $titleAttrValue;
                                        }
                                                // Setting "blurlink()" function:
                                        if (!$this->mconf['noBlur'])    {
                                                $this->I['linkHREF']['onFocus']='blurLink(this);';
                                        }

                                                // Set rollover
                                        if ($this->result['RO'][$key] && !$this->I['noLink'])   {
                                                $this->I['theName'] = $this->imgNamePrefix.$this->I['uid'].$this->I['INPfix'];
                                                $this->I['name'] = ' '.$this->nameAttribute.'="'.$this->I["theName"].'"';
                                                $this->I['linkHREF']['onMouseover']=$this->WMfreezePrefix.'over(\''.$this->I['theName'].'\');';
                                                $this->I['linkHREF']['onMouseout']=$this->WMfreezePrefix.'out(\''.$this->I['theName'].'\');';
                                                $GLOBALS['TSFE']->JSImgCode.= chr(10).$this->I['theName'].'_n=new Image(); '.$this->I['theName'].'_n.src = "'.$GLOBALS['TSFE']->absRefPrefix.$this->I['val']['output_file'].'"; ';
                                                $GLOBALS['TSFE']->JSImgCode.= chr(10).$this->I['theName'].'_h=new Image(); '.$this->I['theName'].'_h.src = "'.$GLOBALS['TSFE']->absRefPrefix.$this->result['RO'][$key]['output_file'].'"; ';
                                                $GLOBALS['TSFE']->imagesOnPage[]=$this->result['RO'][$key]['output_file'];
                                                $GLOBALS['TSFE']->setJS('mouseOver');
                                                $this->extProc_RO($key);
                                        }

                                                // Set altText
                                        $this->I['altText'] = $this->mconf['disableAltText'] ? '' : $this->I['title'].$this->I['accessKey']['alt'];

                                                // Calling extra processing function
                                        $this->extProc_beforeLinking($key);

                                                // Set linking
                                        if (!$this->I['noLink'])        {
                                                $this->setATagParts();
                                        } else {
                                                $this->I['A1'] = '';
                                                $this->I['A2'] = '';
                                        }
                                        $this->I['IMG'] = '<img src="'.$GLOBALS['TSFE']->absRefPrefix.$this->I['val']['output_file'].'" width="'.$this->I['val']['output_w'].'" height="'.$this->I['val']['output_h'].'" '.tslib_cObj::getBorderAttr('border="0"').' alt="'.htmlspecialchars($this->I['altText']).'"'.$this->I['name'].($this->I['val']['imgParams']?' '.$this->I['val']['imgParams']:'').' />';

                                                // Make before, middle and after parts
                                        $this->I['parts'] = array();
                                        $this->I['parts']['ATag_begin'] = $this->I['A1'];
                                        $this->I['parts']['image'] = $this->I['IMG'];
                                        $this->I['parts']['ATag_end'] = $this->I['A2'];

                                                // Passing I to a user function
                                        if ($this->mconf['IProcFunc'])  {
                                                $this->I = $this->userProcess('IProcFunc',$this->I);
                                        }

                                                // Putting the item together.
                                                // Merge parts + beforeAllWrap
                                        $this->I['theItem']= implode('',$this->I['parts']);
                                        $this->I['theItem']= $this->extProc_beforeAllWrap($this->I['theItem'],$key);

                                                // wrap:
                                        $this->I['theItem']= $this->tmpl->wrap($this->I['theItem'],$this->I['val']['wrap']);

                                                // allWrap:
                                        $allWrap = $this->WMcObj->stdWrap($this->I['val']['allWrap'],$this->I['val']['allWrap.']);
                                        $this->I['theItem'] = $this->tmpl->wrap($this->I['theItem'],$allWrap);

                                        if ($this->I['val']['subst_elementUid'])        $this->I['theItem'] = str_replace('{elementUid}',$this->I['uid'],$this->I['theItem']);

                                                // allStdWrap:
                                        if (is_array($this->I['val']['allStdWrap.']))   {
                                                $this->I['theItem'] = $this->WMcObj->stdWrap($this->I['theItem'],$this->I['val']['allStdWrap.']);
                                        }

                                        $GLOBALS['TSFE']->imagesOnPage[]=$this->I['val']['output_file'];

                                        $this->extProc_afterLinking($key);
                                }
                        }
                        return $this->extProc_finish();
                }
        }

        function extProc_init() {
        }

        function extProc_RO($key)       {
        }

        function extProc_beforeLinking($key)    {
        }

        function extProc_afterLinking($key)     {
                $this->WMresult.=$this->I['theItem'];
                if (!$this->I['spacer'])        {
                        $this->WMresult.= $this->subMenu($this->I['uid'], $this->WMsubmenuObjSuffixes[$key]['sOSuffix']);
                }
        }


        function extProc_beforeAllWrap($item,$key)      {
                return $item;
        }

        function extProc_finish()       {
                return $this->tmpl->wrap($this->WMresult,$this->mconf['wrap']).$this->WMextraScript;
        }
}






















class tslib_imgmenu extends tslib_menu {

        function generate()     {
                $splitCount = count($this->menuArr);
                if ($splitCount)        {
                        list($NOconf) = $this->procesItemStates($splitCount);
                }
                if ($this->mconf['debugItemConf'])      {echo '<h3>$NOconf:</h3>';      debug($NOconf); }
                $this->makeImageMap($NOconf);
        }

        function makeImageMap($conf)    {
                if (!is_array($conf)) {
                        $conf = Array();
                }
                if (is_array($this->mconf['main.']))    {
                        $gifCreator = t3lib_div::makeInstance('tslib_gifBuilder');
                        $gifCreator->init();

                        $itemsConf = $conf;
                        $conf = $this->mconf['main.'];
                        if (is_array($conf))    {
                                $gifObjCount = 0;

                                $sKeyArray=t3lib_TStemplate::sortedKeyList($conf);
                                $gifObjCount=intval(end($sKeyArray));

                                $lastOriginal = $gifObjCount;

                                        // Now we add graphical objects to the gifbuilder-setup
                                reset($itemsConf);
                                $waArr = Array();
                                while (list($key,$val)=each($itemsConf))        {
                                        if (is_array($val))     {
                                                $gifObjCount++;
                                                $waArr[$key]['free']=$gifObjCount;

                                                $sKeyArray=t3lib_TStemplate::sortedKeyList($val);

                                                foreach($sKeyArray as $theKey)  {
                                                        $theValue=$val[$theKey];


                                                        if (intval($theKey) && $theValArr=$val[$theKey.'.'])    {
                                                                $cObjData = $this->menuArr[$key] ? $this->menuArr[$key] : Array();

                                                                $gifObjCount++;
                                                                if ($theValue=='TEXT') {
                                                                        $waArr[$key]['textNum']=$gifObjCount;

                                                                        $gifCreator->data = $cObjData;
                                                                        $theValArr = $gifCreator->checkTextObj($theValArr);
                                                                        unset($theValArr['text.']);     // if this is not done it seems that imageMaps will be rendered wrong!!
                                                                                // check links

                                                                        $LD = $this->tmpl->linkData($this->menuArr[$key],$this->mconf['target'],'','',array(),'',$this->mconf['forceTypeValue']);

                                                                                // If access restricted pages should be shown in menus, change the link of such pages to link to a redirection page:
                                                                        $this->changeLinksForAccessRestrictedPages($LD, $this->menuArr[$key], $this->mconf['target'], $this->mconf['forceTypeValue']);

                                                                                // Overriding URL / Target if set to do so:
                                                                        if ($this->menuArr[$key]['_OVERRIDE_HREF'])     {
                                                                                $LD['totalURL'] = $this->menuArr[$key]['_OVERRIDE_HREF'];
                                                                                if ($this->menuArr[$key]['_OVERRIDE_TARGET'])   $LD['target'] = $this->menuArr[$key]['_OVERRIDE_TARGET'];
                                                                        }

                                                                                // Setting target/url for Image Map:
                                                                        if ($theValArr['imgMap.']['url']=='')   {
                                                                                $theValArr['imgMap.']['url'] = $LD['totalURL'];
                                                                        }
                                                                        if ($theValArr['imgMap.']['target']=='')        {
                                                                                $theValArr['imgMap.']['target'] = $LD['target'];
                                                                        }
                                                                        if ($theValArr['imgMap.']['noBlur']=='')        {
                                                                                $theValArr['imgMap.']['noBlur'] = $this->mconf['noBlur'];
                                                                        }
                                                                        if (is_array($theValArr['imgMap.']['altText.']))        {
                                                                                $cObj =t3lib_div::makeInstance('tslib_cObj');
                                                                                $cObj->start($cObjData,'pages');
                                                                                $theValArr['imgMap.']['altText'] = $cObj->stdWrap($theValArr['imgMap.']['altText'], $theValArr['imgMap.']['altText.']);
                                                                                unset($theValArr['imgMap.']['altText.']);
                                                                }
                                                                        if (is_array($theValArr['imgMap.']['titleText.']))      {
                                                                                $cObj =t3lib_div::makeInstance('tslib_cObj');
                                                                                $cObj->start($cObjData,'pages');
                                                                                $theValArr['imgMap.']['titleText'] = $cObj->stdWrap($theValArr['imgMap.']['titleText'], $theValArr['imgMap.']['titleText.']);
                                                                                unset($theValArr['imgMap.']['titleText.']);
                                                                        }
                                                                }
                                                                        // This code goes one level in if the object is an image. If 'file' and/or 'mask' appears to be GIFBUILDER-objects, they are both searched for TEXT objects, and if a textobj is found, it's checked with the currently loaded record!!
                                                                if ($theValue=='IMAGE') {
                                                                        if ($theValArr['file']=='GIFBUILDER')   {
                                                                                $temp_sKeyArray=t3lib_TStemplate::sortedKeyList($theValArr['file.']);
                                                                                reset($temp_sKeyArray);
                                                                                while(list(,$temp_theKey)=each($temp_sKeyArray))        {
                                                                                        if ($theValArr['mask.'][$temp_theKey]=='TEXT')  {
                                                                                                $gifCreator->data = $this->menuArr[$key] ? $this->menuArr[$key] : Array();
                                                                                                $theValArr['mask.'][$temp_theKey.'.'] = $gifCreator->checkTextObj($theValArr['mask.'][$temp_theKey.'.']);
                                                                                                unset($theValArr['mask.'][$temp_theKey.'.']['text.']);  // if this is not done it seems that imageMaps will be rendered wrong!!
                                                                                        }
                                                                                }
                                                                        }
                                                                        if ($theValArr['mask']=='GIFBUILDER')   {
                                                                                $temp_sKeyArray=t3lib_TStemplate::sortedKeyList($theValArr['mask.']);
                                                                                reset($temp_sKeyArray);
                                                                                while(list(,$temp_theKey)=each($temp_sKeyArray))        {
                                                                                        if ($theValArr['mask.'][$temp_theKey]=='TEXT')  {
                                                                                                $gifCreator->data = $this->menuArr[$key] ? $this->menuArr[$key] : Array();
                                                                                                $theValArr['mask.'][$temp_theKey.'.'] = $gifCreator->checkTextObj($theValArr['mask.'][$temp_theKey.'.']);
                                                                                                unset($theValArr['mask.'][$temp_theKey.'.']['text.']);  // if this is not done it seems that imageMaps will be rendered wrong!!
                                                                                        }
                                                                                }
                                                                        }
                                                                }

                                                                        // Checks if disabled is set...
                                                                $setObjFlag=1;
                                                                if ($theValArr['if.'])  {
                                                                        $cObj =t3lib_div::makeInstance('tslib_cObj');
                                                                        $cObj->start($cObjData,'pages');
                                                                        if (!$cObj->checkIf($theValArr['if.'])) {
                                                                                $setObjFlag=0;
                                                                        }
                                                                        unset($theValArr['if.']);
                                                                }
                                                                        // Set the object!
                                                                if ($setObjFlag)        {
                                                                        $conf[$gifObjCount] = $theValue;
                                                                        $conf[$gifObjCount.'.'] = $theValArr;
                                                                }
                                                        }
                                                }
                                        }
                                }

                                $gifCreator->start($conf,$GLOBALS['TSFE']->page);
                                        // calculations

                                $sum=Array(0,0,0,0);
                                reset($waArr);
                                while (list($key,$val)=each($waArr))    {
                                        if ($dConf[$key] =$itemsConf[$key]['distrib'])  {
                                                $textBB = $gifCreator->objBB[$val['textNum']];
                                                $dConf[$key] = str_replace('textX',$textBB[0],$dConf[$key]);
                                                $dConf[$key] = str_replace('textY',$textBB[1],$dConf[$key]);
                                                $dConf[$key] = t3lib_div::intExplode(',',$gifCreator->calcOffset($dConf[$key]));
                                        }
                                }
                                $workArea = t3lib_div::intExplode(',',$gifCreator->calcOffset($this->mconf['dWorkArea']));
                                reset($waArr);
                                while (list($key,$val)=each($waArr))    {
                                        $index = $val['free'];
                                        $gifCreator->setup[$index] = 'WORKAREA';
                                        $workArea[2] = $dConf[$key][2] ? $dConf[$key][2] : $dConf[$key][0];
                                        $workArea[3] = $dConf[$key][3] ? $dConf[$key][3] : $dConf[$key][1];

                                        $gifCreator->setup[$index.'.']['set'] = implode(',',$workArea);
                                        $workArea[0]+=$dConf[$key][0];
                                        $workArea[1]+=$dConf[$key][1];
                                }

                                if ($this->mconf['debugRenumberedObject'])      {echo '<h3>Renumbered GIFBUILDER object:</h3>'; debug($gifCreator->setup);}

                                $gifCreator->createTempSubDir('menu/');
                                $gifFileName = $gifCreator->fileName('menu/');

                                        // Gets the ImageMap from the cache...
                                $imgHash = md5($gifFileName);
                                $imgMap = $this->sys_page->getHash($imgHash, 0);

                                if ($imgMap && @file_exists($gifFileName))      {               // File exists
                                        $info = @getimagesize($gifFileName);
                                        $w=$info[0];
                                        $h=$info[1];
                                } else {                // file is generated
                                        $gifCreator->make();
                                        $w=$gifCreator->w;
                                        $h=$gifCreator->h;
                                        $gifCreator->output($gifFileName);
                                        $gifCreator->destroy();
                                        $imgMap=$gifCreator->map;
                                        $this->sys_page->storeHash($imgHash, $imgMap, 'MENU IMAGEMAP');
                                }
                                $imgMap.=$this->mconf['imgMapExtras'];

                                $gifFileName = t3lib_div::png_to_gif_by_imagemagick($gifFileName);
                                $this->result = Array('output_file'=>$gifFileName, 'output_w'=>$w, 'output_h'=>$h, 'imgMap'=>$imgMap);
                        }
                }
        }

        function writeMenu()    {
                if ($this->result)      {
                        $res = $this->result;
                        $menuName = 'menu_'.t3lib_div::shortMD5($res['imgMap']);        // shortMD5 260900
                        $result = '<img src="'.$GLOBALS['TSFE']->absRefPrefix.$res['output_file'].'" width="'.$res['output_w'].'" height="'.$res['output_h'].'" usemap="#'.$menuName.'" border="0" '.$this->mconf['params'];
                        if (!strstr($result,'alt="'))   $result.=' alt="Menu Image Map"';       // Adding alt attribute if not set.
                        $result.= ' /><map name="'.$menuName.'" id="'.$menuName.'">'.$res['imgMap'].'</map>';

                        $GLOBALS['TSFE']->imagesOnPage[]=$res['output_file'];

                        return $this->tmpl->wrap($result,$this->mconf['wrap']);
                }
        }
}





















class tslib_jsmenu extends tslib_menu {

        function generate()     {
        }

        function writeMenu()    {
                if ($this->id)  {
                                // Making levels:
                        $levels = t3lib_div::intInRange($this->mconf['levels'],1,5);
                        $this->levels = $levels;
                        $this->JSVarName='eid';
                        $this->JSMenuName= $this->mconf['menuName'] ? $this->mconf['menuName'] : 'JSmenu';

                        $JScode="\n var ".$this->JSMenuName." = new JSmenu(".$levels.",'".$this->JSMenuName."Form');";

                        for ($a=1;$a<=$levels;$a++)     {
                                $JScode.="\n var ".$this->JSVarName.$a."=0;";
                        }
                        $JScode.= $this->generate_level($levels,1,$this->id,$this->menuArr,$this->MP_array)."\n";

                        $GLOBALS['TSFE']->additionalHeaderData['JSMenuCode']='<script type="text/javascript" src="'.$GLOBALS['TSFE']->absRefPrefix.'t3lib/jsfunc.menu.js"></script>';
                        $GLOBALS['TSFE']->JSCode.=$JScode;

                                // Printing:
                        $allFormCode="";
                        for ($a=1;$a<=$this->levels;$a++)       {
                                $formCode='';
                                $levelConf = $this->mconf[$a.'.'];
                                $length = $levelConf['width'] ? $levelConf['width'] : 14;
                                $lenghtStr='';
                                for ($b=0;$b<$length;$b++)      {
                                        $lenghtStr.='_';
                                }
                                $height = $levelConf['elements'] ? $levelConf['elements'] : 5;

                                $formCode.= '<select name="selector'.$a.'" onchange="'.$this->JSMenuName.'.act('.$a.');"'.($levelConf['additionalParams']?' '.$levelConf['additionalParams']:'').'>';
                                for ($b=0;$b<$height;$b++)      {
                                        $formCode.= '<option value="0">';
                                        if ($b==0)      {
                                                $formCode.= $lenghtStr;
                                        }
                                        $formCode.='</option>';
                                }
                                $formCode.= '</select>';
                                $allFormCode.=$this->tmpl->wrap($formCode,$levelConf['wrap']);
                        }
                        $formCode = $this->tmpl->wrap($allFormCode,$this->mconf['wrap']);

                        $formCode= '<form action="" method="post" style="margin: 0 0 0 0;" name="'.$this->JSMenuName.'Form">'.$formCode.'</form>';
                        $formCode.='<script type="text/javascript"> /*<![CDATA[*/ '.$this->JSMenuName.'.writeOut(1,'.$this->JSMenuName.'.openID,1); /*]]>*/ </script>';
                        return $this->tmpl->wrap($formCode,$this->mconf['wrapAfterTags']);
                }
        }

        function generate_level($levels,$count,$pid,$menuItemArray='',$MP_array=array())        {
                $levelConf = $this->mconf[$count.'.'];

                        // Translate PID to a mount page, if any:
                $mount_info = $this->sys_page->getMountPointInfo($pid);
                if (is_array($mount_info))      {
                        $MP_array[] = $mount_info['MPvar'];
                        $pid = $mount_info['mount_pid'];
                }

                        // Set "&MP=" var:
                $MP_var = implode(',',$MP_array);
                $MP_params = $MP_var ? '&MP='.rawurlencode($MP_var) : '';

                        // UIDs to ban:
                $banUidArray = $this->getBannedUids();

                        // Initializing variables:
                $var = $this->JSVarName;
                $menuName = $this->JSMenuName;
                $parent = $count==1 ? 0 : $var.($count-1);
                $prev=0;
                $c=0;

                $menuItems = is_array($menuItemArray) ? $menuItemArray : $this->sys_page->getMenu($pid);
                foreach($menuItems as $uid => $data)    {
                        $spacer = (t3lib_div::inList($this->spacerIDList,$data['doktype'])?1:0);                // if item is a spacer, $spacer is set
                        if ($this->mconf['SPC'] || !$spacer)    {       // If the spacer-function is not enabled, spacers will not enter the $menuArr
                                if (!t3lib_div::inList($this->doktypeExcludeList,$data['doktype']) && (!$data['nav_hide'] || $this->conf['includeNotInMenu']) && !t3lib_div::inArray($banUidArray,$uid))        {               // Page may not be 'not_in_menu' or 'Backend User Section' + not in banned uid's
                                        if ($count<$levels)     {
                                                $addLines = $this->generate_level($levels,$count+1,$data['uid'],'',$MP_array);
                                        } else {
                                                $addLines = '';
                                        }
                                        $title=$data['title'];
                                        $url='';
                                        $target='';
                                        if ((!$addLines && !$levelConf['noLink']) || $levelConf['alwaysLink']) {
                                                $LD = $this->tmpl->linkData($data,$this->mconf['target'],'','',array(),$MP_params,$this->mconf['forceTypeValue']);

                                                        // If access restricted pages should be shown in menus, change the link of such pages to link to a redirection page:
                                                $this->changeLinksForAccessRestrictedPages($LD, $data, $this->mconf['target'], $this->mconf['forceTypeValue']);

                                                $url = $LD['totalURL'];
                                                $target = $LD['target'];
                                        }
                                        $codeLines.="\n".$var.$count."=".$menuName.".add(".$parent.",".$prev.",0,".t3lib_div::quoteJSvalue($title, true).",".t3lib_div::quoteJSvalue($GLOBALS['TSFE']->baseUrlWrap($url), true).",".t3lib_div::quoteJSvalue($target, true).");";
                                                // If the active one should be chosen...
                                        $active = ($levelConf['showActive'] && $data['uid'] == $this->tmpl->rootLine[$count]['uid']);
                                                // If the first item should be shown
                                        $first = (!$c && $levelConf['showFirst']);
                                                // do it...
                                        if ($active || $first)  {
                                                if ($count==1)  {
                                                        $codeLines.="\n".$menuName.".openID = ".$var.$count.";";
                                                } else {
                                                        $codeLines.="\n".$menuName.".entry[".$parent."].openID = ".$var.$count.";";
                                                }
                                        }
                                                // Add submenu...
                                        $codeLines.=$addLines;

                                        $prev=$var.$count;
                                        $c++;
                                }
                        }
                }
                if ($this->mconf['firstLabelGeneral'] && !$levelConf['firstLabel'])     {
                        $levelConf['firstLabel'] = $this->mconf['firstLabelGeneral'];
                }
                if ($levelConf['firstLabel'] && $codeLines)     {
                        $codeLines.= chr(10).$menuName.'.defTopTitle['.$count.'] = '.t3lib_div::quoteJSvalue($levelConf['firstLabel'], true).';';
                }
                return $codeLines;
        }
}


if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['tslib/class.tslib_menu.php'])      {
        include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['tslib/class.tslib_menu.php']);
}

?>

---