class.t3lib_page.php

Go to the documentation of this file.

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2004 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 t3lib_pageSelect {
   var $urltypes = Array('','http://','ftp://','mailto:');
   var $where_hid_del = ' AND pages.deleted=0'; // This is not the final clauses. There will normally be conditions for the hidden,starttime and endtime fields as well. You MUST initialize the object by the init() function
   var $sys_language_uid = 0;

      // Versioning preview related:
   var $versioningPreview = FALSE;     // If true, preview of other record versions is allowed. THIS MUST ONLY BE SET IF the page is not cached and truely previewed by a backend user!!!
   var $versionPreviewMap = array(
# EXAMPLE:     'tt_content:421' => 427
   );


      // Internal, dynamic:
   var $error_getRootLine = '';     // Error string set by getRootLine()
   var $error_getRootLine_failPid = 0;    // Error uid set by getRootLine()


   function init($show_hidden)   {
      $this->where_hid_del = ' AND pages.deleted=0 ';
      if (!$show_hidden)   {
         $this->where_hid_del.= 'AND pages.hidden=0 ';
      }
      $this->where_hid_del.= 'AND (pages.starttime<='.$GLOBALS['SIM_EXEC_TIME'].') AND (pages.endtime=0 OR pages.endtime>'.$GLOBALS['SIM_EXEC_TIME'].') ';
   }

















   /*******************************************
    *
    * Selecting page records
    *
    ******************************************/

   function getPage($uid)  {
      $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'pages', 'uid='.intval($uid).$this->where_hid_del);
      if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
#??         $this->versionOL('pages',$row);
         return $this->getPageOverlay($row);
      }
      return Array();
   }

   function getPage_noCheck($uid)   {
      $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'pages', 'uid='.intval($uid).$this->deleteClause('pages'));
      if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
#??         $this->versionOL('pages',$row);
         return $this->getPageOverlay($row);
      }
      return Array();
   }

   function getFirstWebPage($uid)   {
      $output = '';
      $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'pages', 'pid='.intval($uid).$this->where_hid_del, '', 'sorting', '1');
      if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
#??         $this->versionOL('pages',$row);
         $output = $this->getPageOverlay($row);
      }
      $GLOBALS['TYPO3_DB']->sql_free_result($res);
      return $output;
   }

   function getPageIdFromAlias($alias) {
      $alias = strtolower($alias);
      $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid', 'pages', 'alias="'.$GLOBALS['TYPO3_DB']->quoteStr($alias, 'pages').'" AND pid>=0 AND pages.deleted=0');   // "AND pid>=0" is because of versioning...
      if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
         return $row['uid'];
      }
      return 0;
   }

   function getPageOverlay($pageInput,$lUid=-1) {

         // Initialize:
      if ($lUid<0)   $lUid = $this->sys_language_uid;
      unset($row);

         // If language UID is different from zero, do overlay:
      if ($lUid)  {
         $fieldArr = explode(',', $GLOBALS['TYPO3_CONF_VARS']['FE']['pageOverlayFields']);
         if (is_array($pageInput))  {
            $page_id = $pageInput['uid']; // Was the whole record
            $fieldArr = array_intersect($fieldArr,array_keys($pageInput));    // Make sure that only fields which exist in the incoming record are overlaid!
         } else {
            $page_id = $pageInput;  // Was the id
         }

         if (count($fieldArr))   {
            /*
               NOTE to enabledFields('pages_language_overlay'):
               Currently the showHiddenRecords of TSFE set will allow pages_language_overlay records to be selected as they are child-records of a page.
               However you may argue that the showHiddenField flag should determine this. But that's not how it's done right now.
            */

               // Selecting overlay record:
            $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                     implode(',',$fieldArr),
                     'pages_language_overlay',
                     'pid='.intval($page_id).'
                        AND sys_language_uid='.intval($lUid).
                        $this->enableFields('pages_language_overlay'),
                     '',
                     '',
                     '1'
                  );
            $row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
            if (is_array($row))  {
               $row['_PAGES_OVERLAY'] = TRUE;
               $this->versionOL('pages_language_overlay',$row);

                  // Unset vital fields that are NOT allowed to be overlaid:
               unset($row['uid']);
               unset($row['pid']);
            }
         }
      }

         // Create output:
      if (is_array($pageInput))  {
         return is_array($row) ? array_merge($pageInput,$row) : $pageInput;   // If the input was an array, simply overlay the newfound array and return...
      } else {
         return is_array($row) ? $row : array();   // always an array in return
      }
   }

   function getRecordOverlay($table,$row,$sys_language_content,$OLmode='') {
      global $TCA;

      if ($row['uid']>0 && $row['pid']>0) {
         if ($TCA[$table] && $TCA[$table]['ctrl']['languageField'] && $TCA[$table]['ctrl']['transOrigPointerField']) {
            if (!$TCA[$table]['ctrl']['transOrigPointerTable'])   {  // Will not be able to work with other tables (Just didn't implement it yet; Requires a scan over all tables [ctrl] part for first FIND the table that carries localization information for this table (which could even be more than a single table) and then use that. Could be implemented, but obviously takes a little more....)

                  // Will try to overlay a record only if the sys_language_content value is larger that zero.
               if ($sys_language_content>0)  {

                     // Must be default language or [All], otherwise no overlaying:
                  if ($row[$TCA[$table]['ctrl']['languageField']]<=0)   {

                        // Select overlay record:
                     $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                              '*',
                              $table,
                              'pid='.intval($row['pid']).
                                 ' AND '.$TCA[$table]['ctrl']['languageField'].'='.intval($sys_language_content).
                                 ' AND '.$TCA[$table]['ctrl']['transOrigPointerField'].'='.intval($row['uid']).
                                 $this->enableFields($table),
                              '',
                              '',
                              '1'
                           );
                     $olrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
                     $this->versionOL($table,$olrow);
   #debug($row);
   #debug($olrow);
                        // Merge record content by traversing all fields:
                     if (is_array($olrow))   {
                        foreach($row as $fN => $fV)   {
                           if ($fN!='uid' && $fN!='pid' && isset($olrow[$fN]))   {

                              if ($GLOBALS['TSFE']->TCAcachedExtras[$table]['l10n_mode'][$fN]!='exclude'
                                    && ($GLOBALS['TSFE']->TCAcachedExtras[$table]['l10n_mode'][$fN]!='mergeIfNotBlank' || strcmp(trim($olrow[$fN]),''))) {
                                 $row[$fN] = $olrow[$fN];
                              }
                           }
                        }
                     } elseif ($OLmode==='hideNonTranslated' && $row[$TCA[$table]['ctrl']['languageField']]==0)   {  // Unset, if non-translated records should be hidden. ONLY done if the source record really is default language and not [All] in which case it is allowed.
                        unset($row);
                     }

                     // Otherwise, check if sys_language_content is different from the value of the record - that means a japanese site might try to display french content.
                  } elseif ($sys_language_content!=$row[$TCA[$table]['ctrl']['languageField']]) {
                     unset($row);
                  }
               } else {
                     // When default language is displayed, we never want to return a record carrying another language!:
                  if ($row[$TCA[$table]['ctrl']['languageField']]>0) {
                     unset($row);
                  }
               }
            }
         }
      }

      return $row;
   }


















   /*******************************************
    *
    * Page related: Menu, Domain record, Root line
    *
    ******************************************/

   function getMenu($uid,$fields='*',$sortField='sorting',$addWhere='') {
      $output = Array();
      $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery($fields, 'pages', 'pid='.intval($uid).$this->where_hid_del.' '.$addWhere, '', $sortField);
      while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
#??         $this->versionOL('pages',$row);

            // Keep mount point:
         $origUid = $row['uid'];
         $mount_info = $this->getMountPointInfo($origUid, $row);  // $row MUST have "uid", "pid", "doktype", "mount_pid", "mount_pid_ol" fields in it
         if (is_array($mount_info) && $mount_info['overlay'])  {  // There is a valid mount point.
            $mp_row = $this->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 to output array after overlaying language:
         if (is_array($row))  {
            $output[$origUid] = $this->getPageOverlay($row);
         }
      }
      return $output;
   }

   function getDomainStartPage($domain, $path='',$request_uri='') {
      $domain = explode(':',$domain);
      $domain = strtolower(ereg_replace('\.$','',$domain[0]));
         // Removing extra trailing slashes
      $path = trim(ereg_replace('\/[^\/]*$','',$path));
         // Appending to domain string
      $domain.= $path;
      $domain = ereg_replace('\/*$','',$domain);

      $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
               'pages.uid,sys_domain.redirectTo,sys_domain.prepend_params',
               'pages,sys_domain',
               'pages.uid=sys_domain.pid
                  AND sys_domain.hidden=0
                  AND (sys_domain.domainName="'.$GLOBALS['TYPO3_DB']->quoteStr($domain, 'sys_domain').'" OR sys_domain.domainName="'.$GLOBALS['TYPO3_DB']->quoteStr($domain.'/', 'sys_domain').'") '.
                  $this->where_hid_del,
               '',
               '',
               1
            );
      if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
         if ($row['redirectTo']) {
            $rURL = $row['redirectTo'];
            if ($row['prepend_params'])   {
               $rURL = ereg_replace('\/$','',$rURL);
               $prependStr = ereg_replace('^\/','',substr($request_uri,strlen($path)));
               $rURL.='/'.$prependStr;
            }
            Header('Location: '.t3lib_div::locationHeaderUrl($rURL));
            exit;
         } else {
            return $row['uid'];
         }
      }
   }

   function getRootLine($uid, $MP='', $ignoreMPerrors=FALSE)   {

         // Initialize:
      $selFields = t3lib_div::uniqueList('pid,uid,t3ver_oid,title,alias,nav_title,media,layout,hidden,starttime,endtime,fe_group,extendToSubpages,doktype,TSconfig,storage_pid,is_siteroot,mount_pid,mount_pid_ol,'.$GLOBALS['TYPO3_CONF_VARS']['FE']['addRootLineFields']);
      $this->error_getRootLine = '';
      $this->error_getRootLine_failPid = 0;

         // Splitting the $MP parameters if present
      $MPA = array();
      if ($MP) {
         $MPA = explode(',',$MP);
         reset($MPA);
         while(list($MPAk) = each($MPA))  {
            $MPA[$MPAk] = explode('-', $MPA[$MPAk]);
         }
      }

      $loopCheck = 0;
      $theRowArray = Array();
      $uid = intval($uid);

      while ($uid!=0 && $loopCheck<20) {  // Max 20 levels in the page tree.
         $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery($selFields, 'pages', 'uid='.intval($uid).' AND pages.deleted=0 AND pages.doktype!=255');
         if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
            $this->fixVersioningPid('pages',$row);
#??            $this->versionOL('pages',$row);

               // Mount Point page types are allowed ONLY a) if they are the outermost record in rootline and b) if the overlay flag is not set:
            if ($GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids'] && $row['doktype']==7 && !$ignoreMPerrors) {
               $mount_info = $this->getMountPointInfo($row['uid'], $row);
               if ($loopCheck>0 || $mount_info['overlay'])  {
                  $this->error_getRootLine = 'Illegal Mount Point found in rootline';
                  return array();
               }
            }

            $uid = $row['pid'];  // Next uid

            if (count($MPA) && $GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids']) {
               $curMP = end($MPA);
               if (!strcmp($row['uid'],$curMP[0])) {

                  array_pop($MPA);
                  $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery($selFields, 'pages', 'uid='.intval($curMP[1]).' AND pages.deleted=0 AND pages.doktype!=255');
                  $mp_row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);

                  if (is_array($mp_row))  {
                     $this->fixVersioningPid('pages',$mp_row);
#??                     $this->versionOL('pages',$mp_row);
                     $mount_info = $this->getMountPointInfo($mp_row['uid'], $mp_row);
                     if (is_array($mount_info) && $mount_info['mount_pid']==$curMP[0]) {
                        $uid = $mp_row['pid'];  // Setting next uid

                        if ($mount_info['overlay'])   {  // Symlink style: Keep mount point (current row).
                           $row['_MOUNT_OL'] = TRUE;  // Set overlay mode:
                           $row['_MOUNT_PAGE'] = array(
                              'uid' => $mp_row['uid'],
                              'pid' => $mp_row['pid'],
                              'title' =>  $mp_row['title'],
                           );
                        } else { // Normal operation: Insert the mount page row in rootline instead mount point.
                           if ($loopCheck>0) {
                              $row = $mp_row;
                           } else {
                              $this->error_getRootLine = 'Current Page Id is a mounted page of the overlay type and cannot be accessed directly!';
                              return array();   // Matching the page id (first run, $loopCheck = 0) with the MPvar is ONLY allowed if the mount point is the "overlay" type (otherwise it could be forged!)
                           }
                        }

                        $row['_MOUNTED_FROM'] = $curMP[0];
                        $row['_MP_PARAM'] = $mount_info['MPvar'];
                     } else {
                        $this->error_getRootLine = 'MP var was corrupted';
                        return array();   // The MP variables did NOT connect proper mount points:
                     }
                  } else {
                     $this->error_getRootLine = 'No moint point record found according to PID in MP var';
                     return array();   // The second PID in MP var was NOT a valid page.
                  }
               }
            }
               // Add row to rootline with language overlaid:
            $theRowArray[] = $this->getPageOverlay($row);
         } else {
            $this->error_getRootLine = 'Broken rootline';
            $this->error_getRootLine_failPid = $uid;
            return array();   // broken rootline.
         }

         $loopCheck++;
      }

         // If the MPA array is NOT empty, we have to return an error; All MP elements were not resolved!
      if (count($MPA))  {
         $this->error_getRootLine = 'MP value remain!';
         return array();
      }

         // Create output array (with reversed order of numeric keys):
      $output = Array();
      $c = count($theRowArray);
      foreach($theRowArray as $key => $val)  {
         $c--;
         $output[$c] = $val;
      }

      return $output;
   }

   function getPathFromRootline($rl,$len=20) {
      if (is_array($rl))   {
         $c=count($rl);
         $path = '';
         for ($a=0;$a<$c;$a++)   {
            if ($rl[$a]['uid'])  {
               $path.='/'.t3lib_div::fixed_lgd_cs(strip_tags($rl[$a]['title']),$len);
            }
         }
         return $path;
      }
   }

   function getExtURL($pagerow,$disable=0)   {
      if ($pagerow['doktype']==3 && !$disable)  {
         $redirectTo = $this->urltypes[$pagerow['urltype']].$pagerow['url'];

            // If relative path, prefix Site URL:
         $uI = parse_url($redirectTo);
         if (!$uI['scheme'] && substr($redirectTo,0,1)!='/')   { // relative path assumed now...
            $redirectTo = t3lib_div::getIndpEnv('TYPO3_SITE_URL').$redirectTo;
         }
         return $redirectTo;
      }
   }

   function getMountPointInfo($pageId, $pageRec=FALSE, $prevMountPids=array(), $firstPageUid=0) {
      if ($GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids']) {

            // Get pageRec if not supplied:
         if (!is_array($pageRec))   {
            $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid,pid,doktype,mount_pid,mount_pid_ol', 'pages', 'uid='.intval($pageId).' AND pages.deleted=0 AND pages.doktype!=255');
            $pageRec = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
#??            $this->versionOL('pages',$pageRec);
         }

            // Set first Page uid:
         if (!$firstPageUid)  $firstPageUid = $pageRec['uid'];

            // Look for mount pid value plus other required circumstances:
         $mount_pid = intval($pageRec['mount_pid']);
         if (is_array($pageRec) && $pageRec['doktype']==7 && $mount_pid>0 && !in_array($mount_pid, $prevMountPids))  {

               // Get the mount point record (to verify its general existence):
            $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid,pid,doktype,mount_pid,mount_pid_ol', 'pages', 'uid='.$mount_pid.' AND pages.deleted=0 AND pages.doktype!=255');
            $mount_rec = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
            if (is_array($mount_rec))  {
#??               $this->versionOL('pages',$mount_rec);

                  // Look for recursive mount point:
               $prevMountPids[] = $mount_pid;
               $recursiveMountPid = $this->getMountPointInfo($mount_pid, $mount_rec, $prevMountPids, $firstPageUid);

                  // Return mount point information:
               return $recursiveMountPid ?
                        $recursiveMountPid :
                        array(
                           'mount_pid' => $mount_pid,
                           'overlay' => $pageRec['mount_pid_ol'],
                           'MPvar' => $mount_pid.'-'.$firstPageUid,
                           'mount_point_rec' => $pageRec,
                           'mount_pid_rec' => $mount_rec,
                        );
            } else {
               return -1;  // Means, there SHOULD have been a mount point, but there was none!
            }
         }
      }

      return FALSE;
   }

















   /*********************************
    *
    * Selecting records in general
    *
    **********************************/

   function checkRecord($table,$uid,$checkPage=0)  {
      global $TCA;
      $uid=intval($uid);
      if (is_array($TCA[$table])) {
         $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', $table, 'uid='.intval($uid).$this->enableFields($table));
         if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
#??            $this->versionOL($table,$row);
            $GLOBALS['TYPO3_DB']->sql_free_result($res);
            if ($checkPage)   {
               $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid', 'pages', 'uid='.intval($row['pid']).$this->enableFields('pages'));
               if ($GLOBALS['TYPO3_DB']->sql_num_rows($res))   {
                  return $row;
               } else {
                  return 0;
               }
            } else {
               return $row;
            }
         }
      }
   }

   function getRawRecord($table,$uid,$fields='*')  {
      global $TCA;
      $uid = intval($uid);
      if (is_array($TCA[$table]) || $table=='pages') {   // Excluding pages here so we can ask the function BEFORE TCA gets initialized. Support for this is followed up in deleteClause()...
         $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery($fields, $table, 'uid='.intval($uid).$this->deleteClause($table));
         if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
#??            $this->versionOL($table,$row);
            return $row;
         }
      }
   }

   function getRecordsByField($theTable,$theField,$theValue,$whereClause='',$groupBy='',$orderBy='',$limit='') {
      global $TCA;
      if (is_array($TCA[$theTable])) {
         $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                  '*',
                  $theTable,
                  $theField.'="'.$GLOBALS['TYPO3_DB']->quoteStr($theValue, $theTable).'"'.
                     $this->deleteClause($theTable).' '.
                        $whereClause,  // whereClauseMightContainGroupOrderBy
                  $groupBy,
                  $orderBy,
                  $limit
               );
         $rows = array();
         while($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))   {
#??            $this->versionOL($theTable,$row);
            $rows[] = $row;
         }
         $GLOBALS['TYPO3_DB']->sql_free_result($res);
         if (count($rows)) return $rows;
      }
   }














   /*********************************
    *
    * Caching and standard clauses
    *
    **********************************/

   function getHash($hash,$expTime=0)  {
         //
      $expTime = intval($expTime);
      if ($expTime)  {
         $whereAdd = ' AND tstamp > '.(time()-$expTime);
      }
      $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('content', 'cache_hash', 'hash="'.$GLOBALS['TYPO3_DB']->quoteStr($hash, 'cache_hash').'"'.$whereAdd);
      if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
         $GLOBALS['TYPO3_DB']->sql_free_result($res);
         return $row['content'];
      }
   }

   function storeHash($hash,$data,$ident) {
      $insertFields = array(
         'hash' => $hash,
         'content' => $data,
         'ident' => $ident,
         'tstamp' => time()
      );
      $GLOBALS['TYPO3_DB']->exec_DELETEquery('cache_hash', 'hash="'.$GLOBALS['TYPO3_DB']->quoteStr($hash, 'cache_hash').'"');
      $GLOBALS['TYPO3_DB']->exec_INSERTquery('cache_hash', $insertFields);
   }

   function deleteClause($table) {
      global $TCA;
      if (!strcmp($table,'pages'))  {  // Hardcode for pages...:
         return ' AND deleted=0';
      } else {
         return $TCA[$table]['ctrl']['delete'] ? ' AND '.$TCA[$table]['ctrl']['delete'].'=0' : '';
      }
   }

   function enableFields($table,$show_hidden=-1,$ignore_array=array())  {
      if ($show_hidden==-1 && is_object($GLOBALS['TSFE']))  {  // If show_hidden was not set from outside and if TSFE is an object, set it based on showHiddenPage and showHiddenRecords from TSFE
         $show_hidden = $table=='pages' ? $GLOBALS['TSFE']->showHiddenPage : $GLOBALS['TSFE']->showHiddenRecords;
      }
      if ($show_hidden==-1)   $show_hidden=0;   // If show_hidden was not changed during the previous evaluation, do it here.

      $ctrl = $GLOBALS['TCA'][$table]['ctrl'];
      $query='';
      if (is_array($ctrl)) {
         if ($ctrl['delete']) {
            $query.=' AND '.$table.'.'.$ctrl['delete'].'=0';
         }
         if (is_array($ctrl['enablecolumns']))  {
            if ($ctrl['enablecolumns']['disabled'] && !$show_hidden && !$ignore_array['disabled']) {
               $field = $table.'.'.$ctrl['enablecolumns']['disabled'];
               $query.=' AND '.$field.'=0';
            }
            if ($ctrl['enablecolumns']['starttime'] && !$ignore_array['starttime']) {
               $field = $table.'.'.$ctrl['enablecolumns']['starttime'];
               $query.=' AND ('.$field.'<='.$GLOBALS['SIM_EXEC_TIME'].')';
            }
            if ($ctrl['enablecolumns']['endtime'] && !$ignore_array['endtime'])  {
               $field = $table.'.'.$ctrl['enablecolumns']['endtime'];
               $query.=' AND ('.$field.'=0 OR '.$field.'>'.$GLOBALS['SIM_EXEC_TIME'].')';
            }
            if ($ctrl['enablecolumns']['fe_group'] && !$ignore_array['fe_group'])   {
               $field = $table.'.'.$ctrl['enablecolumns']['fe_group'];
               $gr_list = $GLOBALS['TSFE']->gr_list;
               if (!strcmp($gr_list,''))  $gr_list=0;
               $query.=' AND '.$field.' IN ('.$gr_list.')';
            }
         }
      } else {
         die ('NO entry in the $TCA-array for the table "'.$table.'". This means that the function enableFields() is called with an invalid table name as argument.');
      }

      return $query;
   }















   /*********************************
    *
    * Versioning Preview
    *
    **********************************/

   function fixVersioningPid($table,&$rr) {
      global $TCA;
# SWAP uid as well???
      if ($this->versioningPreview && $rr['pid']==-1 && ($table=='pages' || $TCA[$table]['ctrl']['versioning']))  {  // Have to hardcode it for "pages" table since TCA is not loaded at this moment!
         if ($rr['t3ver_oid']>0) {  // If "t3ver_oid" is already a field, just set this:
            $oid = $rr['t3ver_oid'];
         } else { // Otherwise we have to expect "uid" to be in the record and look up based on this:
            $newPidRec = $this->getRawRecord($table,$rr['uid'],'t3ver_oid');
            if (is_array($newPidRec))  {
               $oid = $newPidRec['t3ver_oid'];
            }
         }

            // If ID of current online version is found, look up the PID value of that:
         if ($oid)   {
            $oidRec = $this->getRawRecord($table,$oid,'pid');
            if (is_array($oidRec))  {
               $rr['_ORIG_pid'] = $rr['pid'];
               $rr['pid'] = $oidRec['pid'];
            }
         }
      }
   }

   function versionOL($table,&$row) {
      global $TCA;

      if ($this->versioningPreview && $TCA[$table]['ctrl']['versioning'])  {
#debug($row,$table);
#debug($this->versionPreviewMap);
         if (is_array($row) && isset($this->versionPreviewMap[$table.':'.$row['uid']]))   {

               // ID to look for:
            $lookFor = $this->versionPreviewMap[$table.':'.$row['uid']];

               // Select the alternative version:
            $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', $table, 'uid='.intval($lookFor).$this->deleteClause($table));
            if ($altrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
               if ($altrow['pid']==-1 && $altrow['t3ver_oid']==$row['uid'])   {
                  unset($altrow['pid']);  // Unsetting PID since this is basically the same as what fixVersioningPid would do to the record...
                  unset($altrow['uid']);  // Unsetting UID because the overlaid record should KEEP its own UID.
                  # unset(...);  // more fields being unset???
                  $row = t3lib_div::array_merge_recursive_overrule($row,$altrow,TRUE);
#debug($row,'Found:');
               }
            }
         }
      }
   }
}



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

---