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.t3lib_parsehtml_proc.php

<?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!
***************************************************************/
require_once (PATH_t3lib.'class.t3lib_parsehtml.php');












class t3lib_parsehtml_proc extends t3lib_parsehtml {

                // Static:
        var $headListTags = 'PRE,UL,OL,H1,H2,H3,H4,H5,H6';              // List of tags for header, pre and list containers

                // Internal, static:
        var $recPid = 0;                                // Set this to the pid of the record manipulated by the class.
        var $elRef = '';                                // Element reference [table]:[field], eg. "tt_content:bodytext"
        var $relPath='';                                // Relative path
        var $relBackPath='';                    // Relative back-path
        var $procOptions = '';                  // Set to the TSconfig options coming from Page TSconfig

                // Internal, dynamic
        var $TS_transform_db_safecounter=100;           // Run-away brake for recursive calls.
        var $rte_p='';                                                          // Parameters from TCA types configuration related to the RTE
        var $getKeepTags_cache=array();                         // Data caching for processing function
        var $allowedClasses=array();                            // Storage of the allowed CSS class names in the RTE
        var $preserveTags = '';                                         // Set to tags to preserve from Page TSconfig configuration










        function init($elRef='',$recPid=0)      {
                $this->recPid = $recPid;
                $this->elRef = $elRef;
        }

        function setRelPath($path)      {
                $path = trim($path);
                $path = ereg_replace('^/','',$path);
                $path = ereg_replace('/$','',$path);
                if ($path)      {
                        $this->relPath = $path;
                        $this->relBackPath = '';
                        $partsC=count(explode('/',$this->relPath));
                        for ($a=0;$a<$partsC;$a++)      {
                                $this->relBackPath.='../';
                        }
                        $this->relPath.='/';
                }
        }

        function evalWriteFile($pArr,$currentRecord)    {

                        // Write file configuration:
                if (is_array($pArr))    {
                        if ($GLOBALS['TYPO3_CONF_VARS']['BE']['staticFileEditPath']
                                && substr($GLOBALS['TYPO3_CONF_VARS']['BE']['staticFileEditPath'],-1)=='/'
                                && @is_dir(PATH_site.$GLOBALS['TYPO3_CONF_VARS']['BE']['staticFileEditPath']))  {

                                $SW_p = $pArr['parameters'];
                                $SW_editFileField = trim($SW_p[0]);
                                $SW_editFile = $currentRecord[$SW_editFileField];
                                if ($SW_editFileField && $SW_editFile && t3lib_div::validPathStr($SW_editFile)) {
                                        $SW_relpath = $GLOBALS['TYPO3_CONF_VARS']['BE']['staticFileEditPath'].$SW_editFile;
                                        $SW_editFile = PATH_site.$SW_relpath;
                                        if (@is_file($SW_editFile))     {
                                                return array(
                                                        'editFile' => $SW_editFile,
                                                        'relEditFile' => $SW_relpath,
                                                        'contentField' => trim($SW_p[1]),
                                                        'markerField' => trim($SW_p[2]),
                                                        'loadFromFileField' => trim($SW_p[3]),
                                                        'statusField' => trim($SW_p[4])
                                                );
                                        } else return "ERROR: Editfile '".$SW_relpath."' did not exist";
                                } else return "ERROR: Edit file name could not be found or was bad.";
                        } else return "ERROR: staticFileEditPath was not set, not set correctly or did not exist!";
                }
        }













        /**********************************************
         *
         * Main function
         *
         **********************************************/

        function RTE_transform($value,$specConf,$direction='rte',$thisConfig=array())   {

                        // Init:
                $this->procOptions = $thisConfig['proc.'];
                $this->preserveTags = strtoupper(implode(',',t3lib_div::trimExplode(',',$this->procOptions['preserveTags'])));

                        // Get parameters for rte_transformation:
                $p = $this->rte_p = t3lib_BEfunc::getSpecConfParametersFromArray($specConf['rte_transform']['parameters']);

                        // Setting modes:
                if (strcmp($this->procOptions['overruleMode'],''))      {
                        $modes = array_unique(t3lib_div::trimExplode(',',$this->procOptions['overruleMode']));
                } else {
                        $modes = array_unique(t3lib_div::trimExplode('-',$p['mode']));
                }
                $revmodes = array_flip($modes);

                        // Find special modes and extract them:
                if (isset($revmodes['ts']))     {
                        $modes[$revmodes['ts']] = 'ts_transform,ts_preserve,ts_images,ts_links';
                }
                        // Find special modes and extract them:
                if (isset($revmodes['ts_css'])) {
                        $modes[$revmodes['ts_css']] = 'css_transform,ts_images,ts_links';
                }

                        // Make list unique
                $modes = array_unique(t3lib_div::trimExplode(',',implode(',',$modes),1));

                        // Reverse order if direction is "rte"
                if ($direction=='rte')  {
                        $modes = array_reverse($modes);
                }

                        // Getting additional HTML cleaner configuration. These are applied either before or after the main transformation is done and is thus totally independant processing options you can set up:
                $entry_HTMLparser = $this->procOptions['entryHTMLparser_'.$direction] ? $this->HTMLparserConfig($this->procOptions['entryHTMLparser_'.$direction.'.']) : '';
                $exit_HTMLparser = $this->procOptions['exitHTMLparser_'.$direction] ? $this->HTMLparserConfig($this->procOptions['exitHTMLparser_'.$direction.'.']) : '';

                        // Line breaks of content is unified into char-10 only (removing char 13)
                if (!$this->procOptions['disableUnifyLineBreaks'])      {
                        $value = str_replace(chr(13).chr(10),chr(10),$value);
                }

                        // In an entry-cleaner was configured, pass value through the HTMLcleaner with that:
                if (is_array($entry_HTMLparser))        {
                        $value = $this->HTMLcleaner($value,$entry_HTMLparser[0],$entry_HTMLparser[1],$entry_HTMLparser[2],$entry_HTMLparser[3]);
                }

                        // Traverse modes:
                foreach($modes as $cmd) {
                                // ->DB
                        if ($direction=='db')   {
                                        // Checking for user defined transformation:
                                if ($_classRef = $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_parsehtml_proc.php']['transformation'][$cmd])     {
                                        $_procObj = &t3lib_div::getUserObj($_classRef);
                                        $_procObj->pObj = &$this;
                                        $_procObj->transformationKey = $cmd;
                                        $value = $_procObj->transform_db($value,$this);
                                } else {        // ... else use defaults:
                                        switch($cmd)    {
                                                case 'ts_images':
                                                        $value = $this->TS_images_db($value);
                                                break;
                                                case 'ts_reglinks':
                                                        $value = $this->TS_reglinks($value,'db');
                                                break;
                                                case 'ts_links':
                                                        $value = $this->TS_links_db($value);
                                                break;
                                                case 'ts_preserve':
                                                        $value = $this->TS_preserve_db($value);
                                                break;
                                                case 'ts_transform':
                                                case 'css_transform':
                                                        $value = str_replace(chr(13),'',$value);        // Has a very disturbing effect, so just remove all '13' - depend on '10'
                                                        $this->allowedClasses = t3lib_div::trimExplode(',',strtoupper($this->procOptions['allowedClasses']),1);
                                                        $value = $this->TS_transform_db($value,$cmd=='css_transform');
                                                break;
                                                case 'ts_strip':
                                                        $value = $this->TS_strip_db($value);
                                                break;
                                                default:
                                                break;
                                        }
                                }
                        }
                                // ->RTE
                        if ($direction=='rte')  {
                                        // Checking for user defined transformation:
                                if ($_classRef = $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_parsehtml_proc.php']['transformation'][$cmd])     {
                                        $_procObj = &t3lib_div::getUserObj($_classRef);
                                        $_procObj->pObj = &$this;
                                        $value = $_procObj->transform_rte($value,$this);
                                } else {        // ... else use defaults:
                                        switch($cmd)    {
                                                case 'ts_images':
                                                        $value = $this->TS_images_rte($value);
                                                break;
                                                case 'ts_reglinks':
                                                        $value = $this->TS_reglinks($value,'rte');
                                                break;
                                                case 'ts_links':
                                                        $value = $this->TS_links_rte($value);
                                                break;
                                                case 'ts_preserve':
                                                        $value = $this->TS_preserve_rte($value);
                                                break;
                                                case 'ts_transform':
                                                case 'css_transform':
                                                        $value = str_replace(chr(13),'',$value);        // Has a very disturbing effect, so just remove all '13' - depend on '10'
                                                        $value = $this->TS_transform_rte($value,$cmd=='css_transform');
                                                break;
                                                default:
                                                break;
                                        }
                                }
                        }
                }

                        // In an exit-cleaner was configured, pass value through the HTMLcleaner with that:
                if (is_array($exit_HTMLparser)) {
                        $value = $this->HTMLcleaner($value,$exit_HTMLparser[0],$exit_HTMLparser[1],$exit_HTMLparser[2],$exit_HTMLparser[3]);
                }

                        // Final clean up of linebreaks:
                if (!$this->procOptions['disableUnifyLineBreaks'])      {
                        $value = str_replace(chr(13).chr(10),chr(10),$value);   // Make sure no \r\n sequences has entered in the meantime...
                        $value = str_replace(chr(10),chr(13).chr(10),$value);   // ... and then change all \n into \r\n
                }

                        // Return value:
                return $value;
        }
















        /************************************
         *
         * Specific RTE TRANSFORMATION functions
         *
         *************************************/

        function TS_images_db($value)   {

                        // Split content by <img> tags and traverse the resulting array for processing:
                $imgSplit = $this->splitTags('img',$value);
                foreach($imgSplit as $k => $v)  {
                        if ($k%2)       {       // image found, do processing:

                                        // Init
                                $attribArray = $this->get_tag_attributes_classic($v,1);
                                $siteUrl = $this->siteUrl();
                                $absRef = trim($attribArray['src']);            // It's always a absolute URL coming from the RTE into the Database.

                                        // External image from another URL? In that case, fetch image (unless disabled feature).
                                if (!t3lib_div::isFirstPartOfStr($absRef,$siteUrl) && !$this->procOptions['dontFetchExtPictures'])      {
                                        $externalFile = $this->getUrl($absRef); // Get it
                                        if ($externalFile)      {
                                                $pU = parse_url($absRef);
                                                $pI=pathinfo($pU['path']);

                                                if (t3lib_div::inList('gif,png,jpeg,jpg',strtolower($pI['extension']))) {
                                                        $filename = t3lib_div::shortMD5($absRef).'.'.$pI['extension'];
                                                        $origFilePath = PATH_site.$this->rteImageStorageDir().'RTEmagicP_'.$filename;
                                                        $C_origFilePath = PATH_site.$this->rteImageStorageDir().'RTEmagicC_'.$filename.'.'.$pI['extension'];
                                                        if (!@is_file($origFilePath))   {
                                                                t3lib_div::writeFile($origFilePath,$externalFile);
                                                                t3lib_div::writeFile($C_origFilePath,$externalFile);
                                                        }
                                                        $absRef = $siteUrl.$this->rteImageStorageDir().'RTEmagicC_'.$filename.'.'.$pI['extension'];

                                                        $attribArray['src']=$absRef;
                                                        $params = t3lib_div::implodeAttributes($attribArray,1);
                                                        $imgSplit[$k] = '<img '.$params.' />';
                                                }
                                        }
                                }
                                        // Check image as local file (siteURL equals the one of the image)
                                if (t3lib_div::isFirstPartOfStr($absRef,$siteUrl))      {
                                        $path = rawurldecode(substr($absRef,strlen($siteUrl))); // Rel-path, rawurldecoded for special characters.
                                        $filepath = t3lib_div::getFileAbsFileName($path);               // Abs filepath, locked to relative path of this project.

                                                // Check file existence (in relative dir to this installation!)
                                        if ($filepath && @is_file($filepath))   {

                                                        // If "magic image":
                                                $pathPre=$this->rteImageStorageDir().'RTEmagicC_';
                                                if (t3lib_div::isFirstPartOfStr($path,$pathPre))        {
                                                        // Find original file:
                                                        $pI=pathinfo(substr($path,strlen($pathPre)));
                                                        $filename = substr($pI['basename'],0,-strlen('.'.$pI['extension']));
                                                        $origFilePath = PATH_site.$this->rteImageStorageDir().'RTEmagicP_'.$filename;
                                                        if (@is_file($origFilePath))    {
                                                                $imgObj = t3lib_div::makeInstance('t3lib_stdGraphic');
                                                                $imgObj->init();
                                                                $imgObj->mayScaleUp=0;
                                                                $imgObj->tempPath=PATH_site.$imgObj->tempPath;

                                                                $curInfo = $imgObj->getImageDimensions($filepath);      // Image dimensions of the current image
                                                                $curWH = $this->getWHFromAttribs($attribArray); // Image dimensions as set in the image tag
                                                                        // Compare dimensions:
                                                                if ($curWH[0]!=$curInfo[0] || $curWH[1]!=$curInfo[1])   {
                                                                        $origImgInfo = $imgObj->getImageDimensions($origFilePath);      // Image dimensions of the current image
                                                                        $cW = $curWH[0];
                                                                        $cH = $curWH[1];
                                                                                $cH = 1000;     // Make the image based on the width solely...
                                                                        $imgI = $imgObj->imageMagickConvert($origFilePath,$pI['extension'],$cW.'m',$cH.'m');
                                                                        if ($imgI[3])   {
                                                                                $fI=pathinfo($imgI[3]);
                                                                                @copy($imgI[3],$filepath);      // Override the child file
                                                                                unset($attribArray['style']);
                                                                                $attribArray['width']=$imgI[0];
                                                                                $attribArray['height']=$imgI[1];
                                                                                if (!$attribArray['border'])    $attribArray['border']=0;
                                                                                $params = t3lib_div::implodeAttributes($attribArray,1);
                                                                                $imgSplit[$k]='<img '.$params.' />';
                                                                        }
                                                                }
                                                        }

                                                } elseif ($this->procOptions['plainImageMode']) {       // If "plain image" has been configured:

                                                                // Image dimensions as set in the image tag
                                                        $curWH = $this->getWHFromAttribs($attribArray);
                                                        $attribArray['width'] = $curWH[0];
                                                        $attribArray['height'] = $curWH[1];

                                                                // Forcing values for style and border:
                                                        unset($attribArray['style']);
                                                        if (!$attribArray['border'])    $attribArray['border'] = 0;

                                                                // Finding dimensions of image file:
                                                        $fI = @getimagesize($filepath);

                                                                // Perform corrections to aspect ratio based on configuration:
                                                        switch((string)$this->procOptions['plainImageMode'])    {
                                                                case 'lockDimensions':
                                                                        $attribArray['width']=$fI[0];
                                                                        $attribArray['height']=$fI[1];
                                                                break;
                                                                case 'lockRatioWhenSmaller':    // If the ratio has to be smaller, then first set the width...:
                                                                        if ($attribArray['width']>$fI[0])       $attribArray['width'] = $fI[0];
                                                                case 'lockRatio':
                                                                        if ($fI[0]>0)   {
                                                                                $attribArray['height']=round($attribArray['width']*($fI[1]/$fI[0]));
                                                                        }
                                                                break;
                                                        }

                                                                // Compile the image tag again:
                                                        $params = t3lib_div::implodeAttributes($attribArray,1);
                                                        $imgSplit[$k]='<img '.$params.' />';
                                                }
                                        } else {        // Remove image if it was not found in a proper position on the server!

                                                        // Commented out; removing the image tag might not be that logical...
                                                #$imgSplit[$k]='';
                                        }
                                }

                                        // Convert abs to rel url
                                if ($imgSplit[$k])      {
                                        $attribArray=$this->get_tag_attributes_classic($imgSplit[$k],1);
                                        $absRef = trim($attribArray['src']);
                                        if (t3lib_div::isFirstPartOfStr($absRef,$siteUrl))      {
                                                $attribArray['src'] = $this->relBackPath.substr($absRef,strlen($siteUrl));
                                                if (!isset($attribArray['alt']))        $attribArray['alt']='';         // Must have alt-attribute for XHTML compliance.
                                                $imgSplit[$k]='<img '.t3lib_div::implodeAttributes($attribArray,1,1).' />';
                                        }
                                }
                        }
                }
                return implode('',$imgSplit);
        }

        function TS_images_rte($value)  {

                        // Split content by <img> tags and traverse the resulting array for processing:
                $imgSplit = $this->splitTags('img',$value);
                foreach($imgSplit as $k => $v)  {
                        if ($k%2)       {       // image found:

                                        // Init
                                $attribArray=$this->get_tag_attributes_classic($v,1);
                                $siteUrl = $this->siteUrl();
                                $absRef = trim($attribArray['src']);

                                        // Unless the src attribute is already pointing to an external URL:
                                if (strtolower(substr($absRef,0,4))!='http')    {
                                        $attribArray['src'] = $siteUrl.substr($attribArray['src'],strlen($this->relBackPath));
                                        if (!isset($attribArray['alt']))        $attribArray['alt']='';
                                        $params = t3lib_div::implodeAttributes($attribArray);
                                        $imgSplit[$k]='<img '.$params.' />';
                                }
                        }
                }

                        // return processed content:
                return implode('',$imgSplit);
        }

        function TS_reglinks($value,$direction)         {
                switch($direction)      {
                        case 'rte':
                                return $this->TS_AtagToAbs($value,1);
                        break;
                        case 'db':
                                $siteURL = $this->siteUrl();
                                $blockSplit = $this->splitIntoBlock('A',$value);
                                reset($blockSplit);
                                while(list($k,$v)=each($blockSplit))    {
                                        if ($k%2)       {       // block:
                                                $attribArray=$this->get_tag_attributes_classic($this->getFirstTag($v),1);
                                                        // If the url is local, remove url-prefix
                                                if ($siteURL && substr($attribArray['href'],0,strlen($siteURL))==$siteURL)      {
                                                        $attribArray['href']=$this->relBackPath.substr($attribArray['href'],strlen($siteURL));
                                                }
                                                $bTag='<a '.t3lib_div::implodeAttributes($attribArray,1).'>';
                                                $eTag='</a>';
                                                $blockSplit[$k] = $bTag.$this->TS_reglinks($this->removeFirstAndLastTag($blockSplit[$k]),$direction).$eTag;
                                        }
                                }
                                return implode('',$blockSplit);
                        break;
                }
        }

        function TS_links_db($value)    {

                        // Split content into <a> tag blocks and process:
                $blockSplit = $this->splitIntoBlock('A',$value);
                foreach($blockSplit as $k => $v)        {
                        if ($k%2)       {       // If an A-tag was found:
                                $attribArray = $this->get_tag_attributes_classic($this->getFirstTag($v),1);
                                $info = $this->urlInfoForLinkTags($attribArray['href']);

                                        // Check options:
                                $attribArray_copy = $attribArray;
                                unset($attribArray_copy['href']);
                                unset($attribArray_copy['target']);
                                unset($attribArray_copy['class']);
                                if ($attribArray_copy['rteerror'])      {       // Unset "rteerror" and "style" attributes if "rteerror" is set!
                                        unset($attribArray_copy['style']);
                                        unset($attribArray_copy['rteerror']);
                                }
                                if (!count($attribArray_copy))  {       // Only if href, target and class are the only attributes, we can alter the link!
                                                // Creating the TYPO3 pseudo-tag "<LINK>" for the link (includes href/url, target and class attributes):
                                        $bTag='<LINK '.$info['url'].($attribArray['target']?' '.$attribArray['target']:($attribArray['class']?' -':'')).($attribArray['class']?' '.$attribArray['class']:'').'>';
                                        $eTag='</LINK>';
                                        $blockSplit[$k] = $bTag.$this->TS_links_db($this->removeFirstAndLastTag($blockSplit[$k])).$eTag;
                                } else {        // ... otherwise store the link as a-tag.
                                                // Unsetting 'rtekeep' attribute if that had been set.
                                        unset($attribArray['rtekeep']);
                                                // If the url is local, remove url-prefix
                                        $siteURL = $this->siteUrl();
                                        if ($siteURL && substr($attribArray['href'],0,strlen($siteURL))==$siteURL)      {
                                                $attribArray['href']=$this->relBackPath.substr($attribArray['href'],strlen($siteURL));
                                        }
                                        $bTag='<a '.t3lib_div::implodeAttributes($attribArray,1).'>';
                                        $eTag='</a>';
                                        $blockSplit[$k] = $bTag.$this->TS_links_db($this->removeFirstAndLastTag($blockSplit[$k])).$eTag;
                                }
                        }
                }
                return implode('',$blockSplit);
        }

        function TS_links_rte($value)   {
                $value = $this->TS_AtagToAbs($value);

                        // Split content by the TYPO3 pseudo tag "<LINK>":
                $blockSplit = $this->splitIntoBlock('link',$value,1);
                foreach($blockSplit as $k => $v)        {
                        $error = '';
                        if ($k%2)       {       // block:
                                $tagCode = t3lib_div::trimExplode(' ',trim(substr($this->getFirstTag($v),0,-1)),1);
                                $link_param = $tagCode[1];
                                $href = '';
                                $siteUrl = $this->siteUrl();
                                        // Parsing the typolink data. This parsing is roughly done like in tslib_content->typolink()
                                if(strstr($link_param,'@'))     {               // mailadr
                                        $href = 'mailto:'.eregi_replace('^mailto:','',$link_param);
                                } elseif (substr($link_param,0,1)=='#') {       // check if anchor
                                        $href = $siteUrl.$link_param;
                                } else {
                                        $fileChar=intval(strpos($link_param, '/'));
                                        $urlChar=intval(strpos($link_param, '.'));

                                                // Detects if a file is found in site-root OR is a simulateStaticDocument.
                                        list($rootFileDat) = explode('?',$link_param);
                                        $rFD_fI = pathinfo($rootFileDat);
                                        if (trim($rootFileDat) && !strstr($link_param,'/') && (@is_file(PATH_site.$rootFileDat) || t3lib_div::inList('php,html,htm',strtolower($rFD_fI['extension'])))) {
                                                $href = $siteUrl.$link_param;
                                        } elseif($urlChar && (strstr($link_param,'//') || !$fileChar || $urlChar<$fileChar))    {       // url (external): If doubleSlash or if a '.' comes before a '/'.
                                                if (!ereg('^[a-z]*://',trim(strtolower($link_param))))  {$scheme='http://';} else {$scheme='';}
                                                $href = $scheme.$link_param;
                                        } elseif($fileChar)     {       // file (internal)
                                                $href = $siteUrl.$link_param;
                                        } else {        // integer or alias (alias is without slashes or periods or commas, that is 'nospace,alphanum_x,lower,unique' according to tables.php!!)
                                                $link_params_parts = explode('#',$link_param);
                                                $idPart = trim($link_params_parts[0]);          // Link-data del
                                                if (!strcmp($idPart,''))        { $idPart=$this->recPid; }      // If no id or alias is given, set it to class record pid
                                                if ($link_params_parts[1] && !$sectionMark)     {
                                                        $sectionMark = '#'.trim($link_params_parts[1]);
                                                }
                                                        // Splitting the parameter by ',' and if the array counts more than 1 element it's a id/type/? pair
                                                $pairParts = t3lib_div::trimExplode(',',$idPart);
                                                if (count($pairParts)>1)        {
                                                        $idPart = $pairParts[0];
                                                        // Type ? future support for?
                                                }
                                                        // Checking if the id-parameter is an alias.
                                                if (!t3lib_div::testInt($idPart))       {
                                                        list($idPartR) = t3lib_BEfunc::getRecordsByField('pages','alias',$idPart);
                                                        $idPart = intval($idPartR['uid']);
                                                }
                                                $page = t3lib_BEfunc::getRecord('pages', $idPart);
                                                if (is_array($page))    {       // Page must exist...
                                                        $href = $siteUrl.'?id='.$link_param;
                                                } else {
                                                        #$href = '';
                                                        $href = $siteUrl.'?id='.$link_param;
                                                        $error = 'No page found: '.$idPart;
                                                }
                                        }
                                }

                                // Setting the A-tag:
                                $bTag = '<a href="'.htmlspecialchars($href).'"'.
                                                        ($tagCode[2]&&$tagCode[2]!='-' ? ' target="'.htmlspecialchars($tagCode[2]).'"' : '').
                                                        ($tagCode[3] ? ' class="'.htmlspecialchars($tagCode[3]).'"' : '').
                                                        ($error ? ' rteerror="'.htmlspecialchars($error).'" style="background-color: yellow; border:2px red solid; color: black;"' : '').       // Should be OK to add the style; the transformation back to databsae will remove it...
                                                        '>';
                                $eTag = '</a>';
                                $blockSplit[$k] = $bTag.$this->TS_links_rte($this->removeFirstAndLastTag($blockSplit[$k])).$eTag;
                        }
                }

                        // Return content:
                return implode('',$blockSplit);
        }

        function TS_preserve_db($value) {
                if (!$this->preserveTags)       return $value;

                        // Splitting into blocks for processing (span-tags are used for special tags)
                $blockSplit = $this->splitIntoBlock('span',$value);
                foreach($blockSplit as $k => $v)        {
                        if ($k%2)       {       // block:
                                $attribArray=$this->get_tag_attributes_classic($this->getFirstTag($v));
                                if ($attribArray['specialtag']) {
                                        $theTag = rawurldecode($attribArray['specialtag']);
                                        $theTagName = $this->getFirstTagName($theTag);
                                        $blockSplit[$k] = $theTag.$this->removeFirstAndLastTag($blockSplit[$k]).'</'.$theTagName.'>';
                                }
                        }
                }
                return implode('',$blockSplit);
        }

        function TS_preserve_rte($value)        {
                if (!$this->preserveTags)       return $value;

                $blockSplit = $this->splitIntoBlock($this->preserveTags,$value);
                foreach($blockSplit as $k => $v)        {
                        if ($k%2)       {       // block:
                                $blockSplit[$k] = '<span specialtag="'.rawurlencode($this->getFirstTag($v)).'">'.$this->removeFirstAndLastTag($blockSplit[$k]).'</span>';
                        }
                }
                return implode('',$blockSplit);
        }

        function TS_transform_db($value,$css=FALSE)     {

                        // safety... so forever loops are avoided (they should not occur, but an error would potentially do this...)
                $this->TS_transform_db_safecounter--;
                if ($this->TS_transform_db_safecounter<0)       return $value;

                        // Split the content from RTE by the occurence of these blocks:
                $blockSplit = $this->splitIntoBlock('TABLE,BLOCKQUOTE,'.$this->headListTags,$value);

                $cc=0;
                $aC = count($blockSplit);

                        // Traverse the blocks
                foreach($blockSplit as $k => $v)        {
                        $cc++;
                        $lastBR = $cc==$aC ? '' : chr(10);

                        if ($k%2)       {       // Inside block:

                                        // Init:
                                $tag=$this->getFirstTag($v);
                                $tagName=strtolower($this->getFirstTagName($v));

                                        // Process based on the tag:
                                switch($tagName)        {
                                        case 'blockquote':      // Keep blockquotes, but clean the inside recursively in the same manner as the main code
                                                $blockSplit[$k]='<'.$tagName.'>'.$this->TS_transform_db($this->removeFirstAndLastTag($blockSplit[$k]),$css).'</'.$tagName.'>'.$lastBR;
                                        break;
                                        case 'ol':
                                        case 'ul':      // Transform lists into <typolist>-tags:
                                                if (!$css)      {
                                                        if (!isset($this->procOptions['typolist']) || $this->procOptions['typolist'])   {
                                                                $parts = $this->getAllParts($this->splitIntoBlock('LI',$this->removeFirstAndLastTag($blockSplit[$k])),1,0);
                                                                while(list($k2)=each($parts))   {
                                                                        $parts[$k2]=ereg_replace(chr(10).'|'.chr(13),'',$parts[$k2]);   // remove all linesbreaks!
                                                                        $parts[$k2]=$this->defaultTStagMapping($parts[$k2],'db');
                                                                        $parts[$k2]=$this->cleanFontTags($parts[$k2],0,0,0);
                                                                        $parts[$k2] = $this->HTMLcleaner_db($parts[$k2],strtolower($this->procOptions['allowTagsInTypolists']?$this->procOptions['allowTagsInTypolists']:'br,font,b,i,u,a,img,span,strong,em'));
                                                                }
                                                                if ($tagName=='ol')     { $params=' type="1"'; } else { $params=''; }
                                                                $blockSplit[$k]='<typolist'.$params.'>'.chr(10).implode(chr(10),$parts).chr(10).'</typolist>'.$lastBR;
                                                        }
                                                } else {
                                                        $blockSplit[$k].=$lastBR;
                                                }
                                        break;
                                        case 'table':   // Tables are NOT allowed in any form (unless preserveTables is set or CSS is the mode)
                                                if (!$this->procOptions['preserveTables'] && !$css)     {
                                                        $blockSplit[$k]=$this->TS_transform_db($this->removeTables($blockSplit[$k]));
                                                } else {
                                                        $blockSplit[$k]=str_replace(chr(10),'',$blockSplit[$k]).$lastBR;
                                                }
                                        break;
                                        case 'h1':
                                        case 'h2':
                                        case 'h3':
                                        case 'h4':
                                        case 'h5':
                                        case 'h6':
                                                if (!$css)      {
                                                        $attribArray=$this->get_tag_attributes_classic($tag);
                                                                // Processing inner content here:
                                                        $innerContent = $this->HTMLcleaner_db($this->removeFirstAndLastTag($blockSplit[$k]));

                                                        if (!isset($this->procOptions['typohead']) || $this->procOptions['typohead'])   {
                                                                $type = intval(substr($tagName,1));
                                                                $blockSplit[$k]='<typohead'.
                                                                                                ($type!=6?' type="'.$type.'"':'').
                                                                                                ($attribArray['align']?' align="'.$attribArray['align'].'"':'').
                                                                                                ($attribArray['class']?' class="'.$attribArray['class'].'"':'').
                                                                                                '>'.
                                                                                                $innerContent.
                                                                                                '</typohead>'.
                                                                                                $lastBR;
                                                        } else {
                                                                $blockSplit[$k]='<'.$tagName.
                                                                                                ($attribArray['align']?' align="'.htmlspecialchars($attribArray['align']).'"':'').
                                                                                                ($attribArray['class']?' class="'.htmlspecialchars($attribArray['class']).'"':'').
                                                                                                '>'.
                                                                                                $innerContent.
                                                                                                '</'.$tagName.'>'.
                                                                                                $lastBR;
                                                        }
                                                } else {
                                                        $blockSplit[$k].=$lastBR;
                                                }
                                        break;
                                        default:
                                                $blockSplit[$k].=$lastBR;
                                        break;
                                }
                        } else {        // NON-block:
                                if (strcmp(trim($blockSplit[$k]),''))   {
                                        $blockSplit[$k]=$this->divideIntoLines($blockSplit[$k]).$lastBR;
                                } else unset($blockSplit[$k]);
                        }
                }
                $this->TS_transform_db_safecounter++;

                return implode('',$blockSplit);
        }

        function TS_transform_rte($value,$css=0)        {

                        // Split the content from Database by the occurence of these blocks:
                $blockSplit = $this->splitIntoBlock('TABLE,BLOCKQUOTE,TYPOLIST,TYPOHEAD,'.$this->headListTags,$value);

                        // Traverse the blocks
                foreach($blockSplit as $k => $v)        {
                        if ($k%2)       {       // Inside one of the blocks:

                                        // Init:
                                $tag = $this->getFirstTag($v);
                                $tagName = strtolower($this->getFirstTagName($v));
                                $attribArray = $this->get_tag_attributes_classic($tag);

                                        // Based on tagname, we do transformations:
                                switch($tagName)        {
                                        case 'blockquote':      // Keep blockquotes:
                                                $blockSplit[$k] = $tag.
                                                                                        $this->TS_transform_rte($this->removeFirstAndLastTag($blockSplit[$k]),$css).
                                                                                        '</'.$tagName.'>';
                                        break;
                                        case 'typolist':        // Transform typolist blocks into OL/UL lists. Type 1 is expected to be numerical block
                                                if (!isset($this->procOptions['typolist']) || $this->procOptions['typolist'])   {
                                                        $tListContent = $this->removeFirstAndLastTag($blockSplit[$k]);
                                                        $tListContent = ereg_replace('^[ ]*'.chr(10),'',$tListContent);
                                                        $tListContent = ereg_replace(chr(10).'[ ]*$','',$tListContent);
                                                        $lines = explode(chr(10),$tListContent);
                                                        $typ = $attribArray['type']==1 ? 'ol' : 'ul';
                                                        $blockSplit[$k] = '<'.$typ.'>'.chr(10).
                                                                                                '<li>'.implode('</li>'.chr(10).'<li>',$lines).'</li>'.
                                                                                                '</'.$typ.'>';
                                                }
                                        break;
                                        case 'typohead':        // Transform typohead into Hx tags.
                                                if (!isset($this->procOptions['typohead']) || $this->procOptions['typohead'])   {
                                                        $tC = $this->removeFirstAndLastTag($blockSplit[$k]);
                                                        $typ = t3lib_div::intInRange($attribArray['type'],0,6);
                                                        if (!$typ)      $typ=6;
                                                        $align = $attribArray['align']?' align="'.$attribArray['align'].'"': '';
                                                        $class = $attribArray['class']?' class="'.$attribArray['class'].'"': '';
                                                        $blockSplit[$k] = '<h'.$typ.$align.$class.'>'.
                                                                                                $tC.
                                                                                                '</h'.$typ.'>';
                                                }
                                        break;
                                }
                                $blockSplit[$k+1] = ereg_replace('^[ ]*'.chr(10),'',$blockSplit[$k+1]); // Removing linebreak if typohead
                        } else {        // NON-block:
                                $nextFTN = $this->getFirstTagName($blockSplit[$k+1]);
                                $singleLineBreak = $blockSplit[$k]==chr(10);
                                if (t3lib_div::inList('TABLE,BLOCKQUOTE,TYPOLIST,TYPOHEAD,'.$this->headListTags,$nextFTN))      {       // Removing linebreak if typolist/typohead
                                        $blockSplit[$k] = ereg_replace(chr(10).'[ ]*$','',$blockSplit[$k]);
                                }
                                        // If $blockSplit[$k] is blank then unset the line. UNLESS the line happend to be a single line break.
                                if (!strcmp($blockSplit[$k],'') && !$singleLineBreak)   {
                                        unset($blockSplit[$k]);
                                } else {
                                        $blockSplit[$k] = $this->setDivTags($blockSplit[$k],($this->procOptions['useDIVasParagraphTagForRTE']?'div':'p'));
                                }
                        }
                }
                return implode(chr(10),$blockSplit);
        }

        function TS_strip_db($value)    {
                $value = strip_tags($value,'<'.implode('><',explode(',','b,i,u,a,img,br,div,center,pre,font,hr,sub,sup,p,strong,em,li,ul,ol,blockquote')).'>');
                return $value;
        }














        /***************************************************************
         *
         * Generic RTE transformation, analysis and helper functions
         *
         **************************************************************/

        function getURL($url)   {
                return t3lib_div::getURL($url);
        }

         function HTMLcleaner_db($content,$tagList='')  {
                if (!$tagList)  {
                        $keepTags = $this->getKeepTags('db');
                } else {
                        $keepTags = $this->getKeepTags('db',$tagList);
                }
                $kUknown = $this->procOptions['dontRemoveUnknownTags_db'] ? 1 : 0;              // Default: remove unknown tags.
                $hSC = $this->procOptions['dontUndoHSC_db'] ? 0 : -1;                                   // Default: re-convert literals to characters (that is &lt; to <)

                return $this->HTMLcleaner($content,$keepTags,$kUknown,$hSC);
         }

        function getKeepTags($direction='rte',$tagList='')      {
                if (!is_array($this->getKeepTags_cache[$direction]) || $tagList)        {

                                // Setting up allowed tags:
                        if (strcmp($tagList,''))        {       // If the $tagList input var is set, this will take precedence
                                $keepTags = array_flip(t3lib_div::trimExplode(',',$tagList,1));
                        } else {        // Default is to get allowed/denied tags from internal array of processing options:
                                        // Construct default list of tags to keep:
                                $typoScript_list = 'b,i,u,a,img,br,div,center,pre,font,hr,sub,sup,p,strong,em,li,ul,ol,blockquote,strike,span';
                                $keepTags = array_flip(t3lib_div::trimExplode(',',$typoScript_list.','.strtolower($this->procOptions['allowTags']),1));

                                        // For tags to deny, remove them from $keepTags array:
                                $denyTags = t3lib_div::trimExplode(',',$this->procOptions['denyTags'],1);
                                foreach($denyTags as $dKe)      {
                                        unset($keepTags[$dKe]);
                                }
                        }

                                // Based on the direction of content, set further options:
                        switch ($direction)     {

                                        // GOING from database to Rich Text Editor:
                                case 'rte':
                                                // Transform bold/italics tags to strong/em
                                        if (isset($keepTags['b']))      {$keepTags['b']=array('remap'=>'STRONG');}
                                        if (isset($keepTags['i']))      {$keepTags['i']=array('remap'=>'EM');}

                                                // Transforming keepTags array so it can be understood by the HTMLcleaner function. This basically converts the format of the array from TypoScript (having .'s) to plain multi-dimensional array.
                                        list($keepTags) = $this->HTMLparserConfig($this->procOptions['HTMLparser_rte.'],$keepTags);
                                break;

                                        // GOING from RTE to database:
                                case 'db':
                                                // Transform strong/em back to bold/italics:
                                        if (isset($keepTags['strong'])) { $keepTags['strong']=array('remap'=>'b'); }
                                        if (isset($keepTags['em']))             { $keepTags['em']=array('remap'=>'i'); }

                                                // Setting up span tags if they are allowed:
                                        if (isset($keepTags['span']))           {
                                                $classes=array_merge(array(''),$this->allowedClasses);
                                                $keepTags['span']=array(
                                                        'allowedAttribs'=>'class',
                                                        'fixAttrib' => Array(
                                                                'class' => Array (
                                                                        'list' => $classes,
                                                                        'removeIfFalse' => 1
                                                                )
                                                        ),
                                                        'rmTagIfNoAttrib' => 1
                                                );
                                                if (!$this->procOptions['allowedClasses'])      unset($keepTags['span']['fixAttrib']['class']['list']);
                                        }

                                                // Setting up font tags if they are allowed:
                                        if (isset($keepTags['font']))           {
                                                $colors=array_merge(array(''),t3lib_div::trimExplode(',',$this->procOptions['allowedFontColors'],1));
                                                $keepTags['font']=array(
                                                        'allowedAttribs'=>'face,color,size',
                                                        'fixAttrib' => Array(
                                                                'face' => Array (
                                                                        'removeIfFalse' => 1
                                                                ),
                                                                'color' => Array (
                                                                        'removeIfFalse' => 1,
                                                                        'list'=>$colors
                                                                ),
                                                                'size' => Array (
                                                                        'removeIfFalse' => 1,
                                                                )
                                                        ),
                                                        'rmTagIfNoAttrib' => 1
                                                );
                                                if (!$this->procOptions['allowedFontColors'])   unset($keepTags['font']['fixAttrib']['color']['list']);
                                        }

                                                // Setting further options, getting them from the processiong options:
                                        $TSc = $this->procOptions['HTMLparser_db.'];
                                        if (!$TSc['globalNesting'])     $TSc['globalNesting']='b,i,u,a,center,font,sub,sup,strong,em,strike,span';
                                        if (!$TSc['noAttrib'])  $TSc['noAttrib']='b,i,u,br,center,hr,sub,sup,strong,em,li,ul,ol,blockquote,strike';

                                                // Transforming the array from TypoScript to regular array:
                                        list($keepTags) = $this->HTMLparserConfig($TSc,$keepTags);
                                break;
                        }

                                // Caching (internally, in object memory) the result unless tagList is set:
                        if (!$tagList)  {
                                $this->getKeepTags_cache[$direction] = $keepTags;
                        } else {
                                return $keepTags;
                        }
                }

                        // Return result:
                return $this->getKeepTags_cache[$direction];
        }

        function divideIntoLines($value,$count=5,$returnArray=FALSE)    {

                        // Internalize font tags (move them from OUTSIDE p/div to inside it that is the case):
                if ($this->procOptions['internalizeFontTags'])  {$value = $this->internalizeFontTags($value);}

                        // Setting configuration for processing:
                $allowTagsOutside = t3lib_div::trimExplode(',',strtolower($this->procOptions['allowTagsOutside']?$this->procOptions['allowTagsOutside']:'img'),1);
                $remapParagraphTag = strtoupper($this->procOptions['remapParagraphTag']);
                $divSplit = $this->splitIntoBlock('div,p',$value,1);    // Setting the third param to 1 will eliminate false end-tags. Maybe this is a good thing to do...?

                if ($this->procOptions['keepPDIVattribs'])      {
                        $keepAttribListArr = t3lib_div::trimExplode(',',strtolower($this->procOptions['keepPDIVattribs']),1);
                } else {
                        $keepAttribListArr = array();
                }

                        // Returns plainly the value if there was no div/p sections in it
                if (count($divSplit)<=1 || $count<=0)   {
                        return $value;
                }

                        // Traverse the splitted sections:
                foreach($divSplit as $k => $v)  {
                        if ($k%2)       {       // Inside
                                $v=$this->removeFirstAndLastTag($v);

                                        // Fetching 'sub-lines' - which will explode any further p/div nesting...
                                $subLines = $this->divideIntoLines($v,$count-1,1);
                                if (is_array($subLines))        {       // So, if there happend to be sub-nesting of p/div, this is written directly as the new content of THIS section. (This would be considered 'an error')
                                        // No noting.
                                } else {        //... but if NO subsection was found, we process it as a TRUE line without erronous content:
                                        $subLines = array($subLines);
                                        if (!$this->procOptions['dontConvBRtoParagraph'])       {       // process break-tags, if configured for. Simply, the breaktags will here be treated like if each was a line of content...
                                                $subLines = spliti('<br[[:space:]]*[\/]?>',$v);
                                        }

                                                // Traverse sublines (there is typically one, except if <br/> has been converted to lines as well!)
                                        reset($subLines);
                                        while(list($sk)=each($subLines))        {

                                                        // Clear up the subline for DB.
                                                $subLines[$sk]=$this->HTMLcleaner_db($subLines[$sk]);

                                                        // Get first tag, attributes etc:
                                                $fTag = $this->getFirstTag($divSplit[$k]);
                                                $tagName=strtolower($this->getFirstTagName($divSplit[$k]));
                                                $attribs=$this->get_tag_attributes($fTag);

                                                        // Keep attributes (lowercase)
                                                $newAttribs=array();
                                                if (count($keepAttribListArr))  {
                                                        foreach($keepAttribListArr as $keepA)   {
                                                                if (isset($attribs[0][$keepA])) { $newAttribs[$keepA] = $attribs[0][$keepA]; }
                                                        }
                                                }

                                                        // ALIGN attribute:
                                                if (!$this->procOptions['skipAlign'] && strcmp(trim($attribs[0]['align']),'') && strtolower($attribs[0]['align'])!='left')      {       // Set to value, but not 'left'
                                                        $newAttribs['align']=strtolower($attribs[0]['align']);
                                                }

                                                        // CLASS attribute:
                                                if (!$this->procOptions['skipClass'] && strcmp(trim($attribs[0]['class']),''))  {       // Set to whatever value
                                                        if (!count($this->allowedClasses) || in_array(strtoupper($attribs[0]['class']),$this->allowedClasses))  {
                                                                $newAttribs['class']=$attribs[0]['class'];
                                                        }
                                                }

                                                        // Remove any line break char (10 or 13)
                                                $subLines[$sk]=ereg_replace(chr(10).'|'.chr(13),'',$subLines[$sk]);

                                                        // If there are any attributes or if we are supposed to remap the tag, then do so:
                                                if (count($newAttribs) && strcmp($remapParagraphTag,'1'))               {
                                                        if ($remapParagraphTag=='P')    $tagName='p';
                                                        if ($remapParagraphTag=='DIV')  $tagName='div';
                                                        $subLines[$sk]='<'.trim($tagName.' '.$this->compileTagAttribs($newAttribs)).'>'.$subLines[$sk].'</'.$tagName.'>';
                                                }
                                        }
                                }
                                        // Add the processed line(s)
                                $divSplit[$k] = implode(chr(10),$subLines);

                                        // If it turns out the line is just blank (containing a &nbsp; possibly) then just make it pure blank:
                                if (trim(strip_tags($divSplit[$k]))=='&nbsp;')          $divSplit[$k]='';
                        } else {        // outside div:
                                        // Remove positions which are outside div/p tags and without content
                                $divSplit[$k]=trim(strip_tags($divSplit[$k],'<'.implode('><',$allowTagsOutside).'>'));
                                if (!strcmp($divSplit[$k],''))  unset($divSplit[$k]);   // Remove part if it's empty
                        }
                }

                        // Return value:
                return $returnArray ? $divSplit : implode(chr(10),$divSplit);
        }

        function setDivTags($value,$dT='p')     {

                        // First, setting configuration for the HTMLcleaner function. This will process each line between the <div>/<p> section on their way to the RTE
                $keepTags = $this->getKeepTags('rte');
                $kUknown = $this->procOptions['dontProtectUnknownTags_rte'] ? 0 : 'protect';    // Default: remove unknown tags.
                $hSC = $this->procOptions['dontHSC_rte'] ? 0 : 1;       // Default: re-convert literals to characters (that is &lt; to <)
                $convNBSP = !$this->procOptions['dontConvAmpInNBSP_rte']?1:0;

                        // Divide the content into lines, based on chr(10):
                $parts = explode(chr(10),$value);
                foreach($parts as $k => $v)     {

                                // Processing of line content:
                        if (!strcmp(trim($parts[$k]),''))       {       // If the line is blank, set it to &nbsp;
                                $parts[$k]='&nbsp;';
                        } else {        // Clean the line content:
                                $parts[$k]=$this->HTMLcleaner($parts[$k],$keepTags,$kUknown,$hSC);
                                if ($convNBSP)  $parts[$k]=str_replace('&amp;nbsp;','&nbsp;',$parts[$k]);
                        }

                                // Wrapping the line in <$dT> is not already wrapped:
                        $testStr = strtolower(trim($parts[$k]));
                        if (substr($testStr,0,4)!='<div' || substr($testStr,-6)!='</div>')      {
                                if (substr($testStr,0,2)!='<p' || substr($testStr,-4)!='</p>')  {
                                                // Only set p-tags if there is not already div or p tags:
                                        $parts[$k]='<'.$dT.'>'.$parts[$k].'</'.$dT.'>';
                                }
                        }
                }

                        // Implode result:
                return implode(chr(10),$parts);
        }

        function internalizeFontTags($value)    {

                        // Splitting into font tag blocks:
                $fontSplit = $this->splitIntoBlock('font',$value);

                foreach($fontSplit as $k => $v) {
                        if ($k%2)       {       // Inside
                                $fTag = $this->getFirstTag($v); // Fint font-tag

                                $divSplit_sub = $this->splitIntoBlock('div,p',$this->removeFirstAndLastTag($v),1);
                                if (count($divSplit_sub)>1)     {       // If there were div/p sections inside the font-tag, do something about it...
                                                // traverse those sections:
                                        foreach($divSplit_sub as $k2 => $v2)    {
                                                if ($k2%2)      {       // Inside
                                                        $div_p = $this->getFirstTag($v2);       // Fint font-tag
                                                        $div_p_tagname = $this->getFirstTagName($v2);   // Fint font-tag
                                                        $v2=$this->removeFirstAndLastTag($v2); // ... and remove it from original.
                                                        $divSplit_sub[$k2]=$div_p.$fTag.$v2.'</font>'.'</'.$div_p_tagname.'>';
                                                } elseif (trim(strip_tags($v2))) {
                                                        $divSplit_sub[$k2]=$fTag.$v2.'</font>';
                                                }
                                        }
                                        $fontSplit[$k]=implode('',$divSplit_sub);
                                }
                        }
                }

                return implode('',$fontSplit);
        }

        function siteUrl()      {
                return t3lib_div::getIndpEnv('TYPO3_SITE_URL');
        }

        function rteImageStorageDir()   {
                return $this->rte_p['imgpath'] ? $this->rte_p['imgpath'] : $GLOBALS['TYPO3_CONF_VARS']['BE']['RTE_imageStorageDir'];
        }

        function removeTables($value,$breakChar='<br />')       {

                        // Splitting value into table blocks:
                $tableSplit = $this->splitIntoBlock('table',$value);

                        // Traverse blocks of tables:
                foreach($tableSplit as $k => $v)        {
                        if ($k%2)       {
                                $tableSplit[$k]='';
                                $rowSplit = $this->splitIntoBlock('tr',$v);
                                foreach($rowSplit as $k2 => $v2)        {
                                        if ($k2%2)      {
                                                $cellSplit = $this->getAllParts($this->splitIntoBlock('td',$v2),1,0);
                                                foreach($cellSplit as $k3 => $v3)       {
                                                        $tableSplit[$k].=$v3.$breakChar;
                                                }
                                        }
                                }
                        }
                }

                        // Implode it all again:
                return implode($breakChar,$tableSplit);
        }

        function defaultTStagMapping($code,$direction='rte')    {
                if ($direction=='db')   {
                        $code=$this->mapTags($code,array(       // Map tags
                                'strong' => 'b',
                                'em' => 'i'
                        ));
                }
                if ($direction=='rte')  {
                        $code=$this->mapTags($code,array(       // Map tags
                                'b' => 'strong',
                                'i' => 'em'
                        ));
                }
                return $code;
        }

        function getWHFromAttribs($attribArray) {
                $style =trim($attribArray['style']);
                if ($style)     {
                        $regex='[[:space:]]*:[[:space:]]*([0-9]*)[[:space:]]*px';
                                // Width
                        eregi('width'.$regex,$style,$reg);
                        $w = intval($reg[1]);
                                // Height
                        eregi('height'.$regex,$style,$reg);
                        $h = intval($reg[1]);
                }
                if (!$w)        {
                        $w = $attribArray['width'];
                }
                if (!$h)        {
                        $h = $attribArray['height'];
                }
                return array(intval($w),intval($h));
        }

        function urlInfoForLinkTags($url)       {
                $info = array();
                $url = trim($url);
                if (substr(strtolower($url),0,7)=='mailto:')    {
                        $info['url']=trim(substr($url,7));
                        $info['type']='email';
                } else {
                        $curURL = $this->siteUrl();     // 100502, removed this: 'http://'.t3lib_div::getThisUrl(); Reason: The url returned had typo3/ in the end - should be only the site's url as far as I see...
                        for($a=0;$a<strlen($url);$a++)  {
                                if ($url[$a]!=$curURL[$a])      {
                                        break;
                                }
                        }

                        $info['relScriptPath']=substr($curURL,$a);
                        $info['relUrl']=substr($url,$a);
                        $info['url']=$url;
                        $info['type']='ext';

                        $siteUrl_parts = parse_url($url);
                        $curUrl_parts = parse_url($curURL);

                        if ($siteUrl_parts['host']==$curUrl_parts['host']       // Hosts should match
                                && (!$info['relScriptPath']     || (defined('TYPO3_mainDir') && substr($info['relScriptPath'],0,strlen(TYPO3_mainDir))==TYPO3_mainDir)))        {       // If the script path seems to match or is empty (FE-EDIT)

                                        // New processing order 100502
                                $uP=parse_url($info['relUrl']);

                                if (!strcmp('#'.$siteUrl_parts['fragment'],$info['relUrl'])) {
                                        $info['url']=$info['relUrl'];
                                        $info['type']='anchor';
                                } elseif (!trim($uP['path']) || !strcmp($uP['path'],'index.php'))       {
                                        $pp = explode('id=',$uP['query']);
                                        $id = trim($pp[1]);
                                        if ($id)        {
                                                $info['pageid']=$id;
                                                $info['cElement']=$uP['fragment'];
                                                $info['url']=$id.($info['cElement']?'#'.$info['cElement']:'');
                                                $info['type']='page';
                                        }
                                } else {
                                        $info['url']=$info['relUrl'];
                                        $info['type']='file';
                                }
                        } else {
                                unset($info['relScriptPath']);
                                unset($info['relUrl']);
                        }
                }
                return $info;
        }

        function TS_AtagToAbs($value,$dontSetRTEKEEP=FALSE)     {
                $blockSplit = $this->splitIntoBlock('A',$value);
                reset($blockSplit);
                while(list($k,$v)=each($blockSplit))    {
                        if ($k%2)       {       // block:
                                $attribArray = $this->get_tag_attributes_classic($this->getFirstTag($v),1);

                                        // Checking if there is a scheme, and if not, prepend the current url.
                                if (strlen($attribArray['href']))       {       // ONLY do this if href has content - the <a> tag COULD be an anchor and if so, it should be preserved...
                                        $uP = parse_url(strtolower($attribArray['href']));
                                        if (!$uP['scheme'])     {
                                                $attribArray['href'] = $this->siteUrl().substr($attribArray['href'],strlen($this->relBackPath));
                                        }
                                } else {
                                        $attribArray['rtekeep'] = 1;
                                }
                                if (!$dontSetRTEKEEP)   $attribArray['rtekeep'] = 1;

                                $bTag='<a '.t3lib_div::implodeAttributes($attribArray,1).'>';
                                $eTag='</a>';
                                $blockSplit[$k] = $bTag.$this->TS_AtagToAbs($this->removeFirstAndLastTag($blockSplit[$k])).$eTag;
                        }
                }
                return implode('',$blockSplit);
        }
}


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

---