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

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



class tx_cssstyledcontent_pi1 extends tslib_pibase {

                // Default plugin variables:
        var $prefixId = 'tx_cssstyledcontent_pi1';              // Same as class name
        var $scriptRelPath = 'pi1/class.tx_cssstyledcontent_pi1.php';   // Path to this script relative to the extension dir.
        var $extKey = 'css_styled_content';             // The extension key.
        var $conf = array();







        /***********************************
         *
         * Rendering of Content Elements:
         *
         ***********************************/

        function render_bullets($content,$conf) {

                        // Look for hook before running default code for function
                if ($hookObj = &$this->hookRequest('render_bullets'))   {
                        return $hookObj->render_bullets($content,$conf);
                } else {

                                // Get bodytext field content, returning blank if empty:
                        $content = trim($this->cObj->data['bodytext']);
                        if (!strcmp($content,''))       return '';

                                // Split into single lines:
                        $lines = t3lib_div::trimExplode(chr(10),$content);
                        while(list($k)=each($lines))    {
                                $lines[$k]='
                                        <li>'.$this->cObj->stdWrap($lines[$k],$conf['innerStdWrap.']).'</li>';
                        }

                                // Set header type:
                        $type = intval($this->cObj->data['layout']);

                                // Compile list:
                        $out = '
                                <ul class="csc-bulletlist csc-bulletlist-'.$type.'">'.
                                        implode('',$lines).'
                                </ul>';

                                // Calling stdWrap:
                        if ($conf['stdWrap.']) {
                                $out = $this->cObj->stdWrap($out, $conf['stdWrap.']);
                        }

                                // Return value
                        return $out;
                }
        }

        function render_table($content,$conf)   {

                        // Look for hook before running default code for function
                if ($hookObj = &$this->hookRequest('render_table'))     {
                        return $hookObj->render_table($content,$conf);
                } else {
                                // Init FlexForm configuration
                        $this->pi_initPIflexForm();

                                // Get bodytext field content
                        $content = trim($this->cObj->data['bodytext']);
                        if (!strcmp($content,''))       return '';

                                // get flexform values
                        $caption = trim(htmlspecialchars($this->pi_getFFvalue($this->cObj->data['pi_flexform'], 'acctables_caption')));
                        $summary = trim(htmlspecialchars($this->pi_getFFvalue($this->cObj->data['pi_flexform'], 'acctables_summary')));
                        $useTfoot = trim($this->pi_getFFvalue($this->cObj->data['pi_flexform'], 'acctables_tfoot'));
                        $headerPos = $this->pi_getFFvalue($this->cObj->data['pi_flexform'], 'acctables_headerpos');
                        $noStyles = $this->pi_getFFvalue($this->cObj->data['pi_flexform'], 'acctables_nostyles');
                        $tableClass = $this->pi_getFFvalue($this->cObj->data['pi_flexform'], 'acctables_tableclass');

                        $delimiter = trim($this->pi_getFFvalue($this->cObj->data['pi_flexform'], 'tableparsing_delimiter','s_parsing'));
                        if ($delimiter) {
                                $delimiter = chr(intval($delimiter));
                        } else {
                                $delimiter = '|';
                        }
                        $quotedInput = trim($this->pi_getFFvalue($this->cObj->data['pi_flexform'], 'tableparsing_quote','s_parsing'));
                        if ($quotedInput)       {
                                $quotedInput = chr(intval($quotedInput));
                        } else {
                                $quotedInput = '';
                        }

                                // generate id prefix for accessible header
                        $headerScope = ($headerPos=='top'?'col':'row');
                        $headerIdPrefix = $headerScope.$this->cObj->data['uid'].'-';

                                // Split into single lines (will become table-rows):
                        $rows = t3lib_div::trimExplode(chr(10),$content);

                                // Find number of columns to render:
                        $cols = t3lib_div::intInRange($this->cObj->data['cols']?$this->cObj->data['cols']:count(explode($delimiter,current($rows))),0,100);

                                // Traverse rows (rendering the table here)
                        $rCount = count($rows);
                        foreach($rows as $k => $v)      {
                                $cells = explode($delimiter,$v);
                                $newCells=array();
                                for($a=0;$a<$cols;$a++) {
                                                // remove quotes if needed
                                        if ($quotedInput && substr($cells[$a],0,1) == $quotedInput && substr($cells[$a],-1,1) == $quotedInput)  {
                                                $cells[$a] = substr($cells[$a],1,-1);
                                        }

                                        if (!strcmp(trim($cells[$a]),''))       $cells[$a]='&nbsp;';
                                        $cellAttribs = ($noStyles?'':($a>0 && ($cols-1)==$a) ? ' class="td-last"' : ' class="td-'.$a.'"');
                                        if (($headerPos == 'top' && !$k) || ($headerPos == 'left' && !$a))      {
                                                $scope = ' scope="'.$headerScope.'"';
                                                $scope .= ' id="'.$headerIdPrefix.(($headerScope=='col')?$a:$k).'"';

                                                $newCells[$a] = '
                                                        <th'.$cellAttribs.$scope.'>'.$this->cObj->stdWrap($cells[$a],$conf['innerStdWrap.']).'</th>';
                                        } else {
                                                if (empty($headerPos))  {
                                                        $accessibleHeader = '';
                                                } else {
                                                        $accessibleHeader = ' headers="'.$headerIdPrefix.(($headerScope=='col')?$a:$k).'"';
                                                }
                                                $newCells[$a] = '
                                                        <td'.$cellAttribs.$accessibleHeader.'>'.$this->cObj->stdWrap($cells[$a],$conf['innerStdWrap.']).'</td>';
                                        }
                                }
                                if (!$noStyles) {
                                        $oddEven = $k%2 ? 'tr-odd' : 'tr-even';
                                        $rowAttribs =  ($k>0 && ($rCount-1)==$k) ? ' class="'.$oddEven.' tr-last"' : ' class="'.$oddEven.' tr-'.$k.'"';
                                }
                                $rows[$k]='
                                        <tr'.$rowAttribs.'>'.implode('',$newCells).'
                                        </tr>';
                        }

                        $addTbody = 0;
                        $tableContents = '';
                        if ($caption)   {
                                $tableContents .= '
                                        <caption>'.$caption.'</caption>';
                        }
                        if ($headerPos == 'top' && $rows[0])    {
                                $tableContents .= '<thead>'. $rows[0] .'
                                        </thead>';
                                unset($rows[0]);
                                $addTbody = 1;
                        }
                        if ($useTfoot)  {
                                $tableContents .= '
                                        <tfoot>'.$rows[$rCount-1].'</tfoot>';
                                unset($rows[$rCount-1]);
                                $addTbody = 1;
                        }
                        $tmpTable = implode('',$rows);
                        if ($addTbody)  {
                                $tmpTable = '<tbody>'.$tmpTable.'</tbody>';
                        }
                        $tableContents .= $tmpTable;

                                // Set header type:
                        $type = intval($this->cObj->data['layout']);

                                // Table tag params.
                        $tableTagParams = $this->getTableAttributes($conf,$type);
                        if (!$noStyles) {
                                $tableTagParams['class'] = 'contenttable contenttable-'.$type.($tableClass?' '.$tableClass:'');
                        } elseif ($tableClass) {
                                $tableTagParams['class'] = $tableClass;
                        }


                                // Compile table output:
                        $out = '
                                <table '.t3lib_div::implodeAttributes($tableTagParams).($summary?' summary="'.$summary.'"':'').'>'.     // Omitted xhtmlSafe argument TRUE - none of the values will be needed to be converted anyways, no need to spend processing time on that.
                                $tableContents.'
                                </table>';

                                // Calling stdWrap:
                        if ($conf['stdWrap.']) {
                                $out = $this->cObj->stdWrap($out, $conf['stdWrap.']);
                        }

                                // Return value
                        return $out;
                }
        }

        function render_uploads($content,$conf) {

                        // Look for hook before running default code for function
                if ($hookObj = &$this->hookRequest('render_uploads'))   {
                        return $hookObj->render_uploads($content,$conf);
                } else {

                        $out = '';

                                // Set layout type:
                        $type = intval($this->cObj->data['layout']);

                                // Get the list of files (using stdWrap function since that is easiest)
                        $lConf = array();
                        $lConf['override.']['filelist.']['field'] = 'select_key';
                        $fileList = $this->cObj->stdWrap($this->cObj->data['media'],$lConf);

                                // Explode into an array:
                        $fileArray = t3lib_div::trimExplode(',',$fileList,1);

                                // If there were files to list...:
                        if (count($fileArray))  {

                                        // Get the path from which the images came:
                                $selectKeyValues = explode('|',$this->cObj->data['select_key']);
                                $path = trim($selectKeyValues[0]) ? trim($selectKeyValues[0]) : 'uploads/media/';

                                        // Get the descriptions for the files (if any):
                                $descriptions = t3lib_div::trimExplode(chr(10),$this->cObj->data['imagecaption']);

                                        // Adding hardcoded TS to linkProc configuration:
                                $conf['linkProc.']['path.']['current'] = 1;
                                $conf['linkProc.']['icon'] = 1; // Always render icon - is inserted by PHP if needed.
                                $conf['linkProc.']['icon.']['wrap'] = ' | //**//';      // Temporary, internal split-token!
                                $conf['linkProc.']['icon_link'] = 1;    // ALways link the icon
                                $conf['linkProc.']['icon_image_ext_list'] = ($type==2 || $type==3) ? $GLOBALS['TYPO3_CONF_VARS']['GFX']['imagefile_ext'] : '';  // If the layout is type 2 or 3 we will render an image based icon if possible.

                                        // Traverse the files found:
                                $filesData = array();
                                foreach($fileArray as $key => $fileName)        {
                                        $absPath = t3lib_div::getFileAbsFileName($path.$fileName);
                                        if (@is_file($absPath)) {
                                                $fI = pathinfo($fileName);
                                                $filesData[$key] = array();

                                                $filesData[$key]['filename'] = $fileName;
                                                $filesData[$key]['path'] = $path;
                                                $filesData[$key]['filesize'] = filesize($absPath);
                                                $filesData[$key]['fileextension'] = strtolower($fI['extension']);
                                                $filesData[$key]['description'] = trim($descriptions[$key]);

                                                $this->cObj->setCurrentVal($path);
                                                $GLOBALS['TSFE']->register['ICON_REL_PATH'] = $path.$fileName;
                                                $filesData[$key]['linkedFilenameParts'] = explode('//**//',$this->cObj->filelink($fileName, $conf['linkProc.']));
                                        }
                                }

                                        // Now, lets render the list!
                                $tRows = array();
                                foreach($filesData as $key => $fileD)   {

                                                // Setting class of table row for odd/even rows:
                                        $oddEven = $key%2 ? 'tr-odd' : 'tr-even';

                                                // Render row, based on the "layout" setting
                                        $tRows[]='
                                        <tr class="'.$oddEven.'">'.($type>0 ? '
                                                <td class="csc-uploads-icon">
                                                        '.$fileD['linkedFilenameParts'][0].'
                                                </td>' : '').'
                                                <td class="csc-uploads-fileName">
                                                        <p>'.$fileD['linkedFilenameParts'][1].'</p>'.
                                                        ($fileD['description'] ? '
                                                        <p class="csc-uploads-description">'.htmlspecialchars($fileD['description']).'</p>' : '').'
                                                </td>'.($this->cObj->data['filelink_size'] ? '
                                                <td class="csc-uploads-fileSize">
                                                        <p>'.t3lib_div::formatSize($fileD['filesize']).'</p>
                                                </td>' : '').'
                                        </tr>';
                                }

                                        // Table tag params.
                                $tableTagParams = $this->getTableAttributes($conf,$type);
                                $tableTagParams['class'] = 'csc-uploads csc-uploads-'.$type;


                                        // Compile it all into table tags:
                                $out = '
                                <table '.t3lib_div::implodeAttributes($tableTagParams).'>
                                        '.implode('',$tRows).'
                                </table>';
                        }

                                // Calling stdWrap:
                        if ($conf['stdWrap.']) {
                                $out = $this->cObj->stdWrap($out, $conf['stdWrap.']);
                        }

                                // Return value
                        return $out;
                }
        }

         function render_textpic($content, $conf)       {
                        // Look for hook before running default code for function
                if (method_exists($this, 'hookRequest') && $hookObj = &$this->hookRequest('render_textpic'))    {
                        return $hookObj->render_textpic($content,$conf);
                }

                $renderMethod = $this->cObj->stdWrap($conf['renderMethod'], $conf['renderMethod.']);

                        // Render using the default IMGTEXT code (table-based)
                if (!$renderMethod || $renderMethod == 'table') {
                        return $this->cObj->IMGTEXT($conf);
                }

                        // Specific configuration for the chosen rendering method
                if (is_array($conf['rendering.'][$renderMethod . '.'])) {
                        $conf = $this->cObj->joinTSarrays($conf, $conf['rendering.'][$renderMethod . '.']);
                }

                        // Image or Text with Image?
                if (is_array($conf['text.']))   {
                        $content = $this->cObj->stdWrap($this->cObj->cObjGet($conf['text.'], 'text.'), $conf['text.']);
                }

                $imgList = trim($this->cObj->stdWrap($conf['imgList'], $conf['imgList.']));

                if (!$imgList)  {
                                // No images, that's easy
                        if (is_array($conf['stdWrap.']))        {
                                return $this->cObj->stdWrap($content, $conf['stdWrap.']);
                        }
                        return $content;
                }

                $imgs = t3lib_div::trimExplode(',', $imgList);
                $imgStart = intval($this->cObj->stdWrap($conf['imgStart'], $conf['imgStart.']));
                $imgCount = count($imgs) - $imgStart;
                $imgMax = intval($this->cObj->stdWrap($conf['imgMax'], $conf['imgMax.']));
                if ($imgMax)    {
                        $imgCount = t3lib_div::intInRange($imgCount, 0, $conf['imgMax']);       // reduce the number of images.
                }

                $imgPath = $this->cObj->stdWrap($conf['imgPath'], $conf['imgPath.']);

                        // Global caption
                $caption = '';
                if (!$conf['captionSplit'] && !$conf['imageTextSplit'] && is_array($conf['caption.']))  {
                        $caption = $this->cObj->stdWrap($this->cObj->cObjGet($conf['caption.'], 'caption.'), $conf['caption.']);
                }

                        // Positioning
                $position = $this->cObj->stdWrap($conf['textPos'], $conf['textPos.']);

                $imagePosition = $position&7;   // 0,1,2 = center,right,left
                $contentPosition = $position&24;        // 0,8,16,24 (above,below,intext,intext-wrap)
                $align = $this->cObj->align[$imagePosition];
                $textMargin = intval($this->cObj->stdWrap($conf['textMargin'],$conf['textMargin.']));
                if (!$conf['textMargin_outOfText'] && $contentPosition < 16)    {
                        $textMargin = 0;
                }

                $colspacing = intval($this->cObj->stdWrap($conf['colSpace'], $conf['colSpace.']));
                $rowspacing = intval($this->cObj->stdWrap($conf['rowSpace'], $conf['rowSpace.']));

                $border = intval($this->cObj->stdWrap($conf['border'], $conf['border.'])) ? 1:0;
                $borderColor = $this->cObj->stdWrap($conf['borderCol'], $conf['borderCol.']);
                $borderThickness = intval($this->cObj->stdWrap($conf['borderThick'], $conf['borderThick.']));

                $borderColor = $borderColor?$borderColor:'black';
                $borderThickness = $borderThickness?$borderThickness:1;
                $borderSpace = (($conf['borderSpace']&&$border) ? intval($conf['borderSpace']) : 0);

                        // Generate cols
                $cols = intval($this->cObj->stdWrap($conf['cols'],$conf['cols.']));
                $colCount = ($cols > 1) ? $cols : 1;
                if ($colCount > $imgCount)      {$colCount = $imgCount;}
                $rowCount = ceil($imgCount / $colCount);

                        // Generate rows
                $rows = intval($this->cObj->stdWrap($conf['rows'],$conf['rows.']));
                if ($rows>1)    {
                        $rowCount = $rows;
                        if ($rowCount > $imgCount)      {$rowCount = $imgCount;}
                        $colCount = ($rowCount>1) ? ceil($imgCount / $rowCount) : $imgCount;
                }

                        // Max Width
                $maxW = intval($this->cObj->stdWrap($conf['maxW'], $conf['maxW.']));

                if ($contentPosition>=16)       {       // in Text
                        $maxWInText = intval($this->cObj->stdWrap($conf['maxWInText'],$conf['maxWInText.']));
                        if (!$maxWInText)       {
                                        // If maxWInText is not set, it's calculated to the 50% of the max
                                $maxW = round($maxW/100*50);
                        } else {
                                $maxW = $maxWInText;
                        }
                }

                        // All columns have the same width:
                $defaultColumnWidth = ceil(($maxW-$colspacing*($colCount-1)-$colCount*$border*($borderThickness+$borderSpace)*2)/$colCount);

                        // Specify the maximum width for each column
                $columnWidths = array();
                $colRelations = trim($this->cObj->stdWrap($conf['colRelations'],$conf['colRelations.']));
                if (!$colRelations)     {
                                // Default 1:1-proportion, all columns same width
                        for ($a=0;$a<$colCount;$a++)    {
                                $columnWidths[$a] = $defaultColumnWidth;
                        }
                } else {
                                // We need another proportion
                        $rel_parts = explode(':',$colRelations);
                        $rel_total = 0;
                        for ($a=0;$a<$colCount;$a++)    {
                                $rel_parts[$a] = intval($rel_parts[$a]);
                                $rel_total+= $rel_parts[$a];
                        }
                        if ($rel_total) {
                                for ($a=0;$a<$colCount;$a++)    {
                                        $columnWidths[$a] = round(($defaultColumnWidth*$colCount)/$rel_total*$rel_parts[$a]);
                                }
                                if (min($columnWidths)<=0 || max($rel_parts)/min($rel_parts)>10)        {
                                        // The difference in size between the largest and smalles must be within a factor of ten.
                                        for ($a=0;$a<$colCount;$a++)    {
                                                $columnWidths[$a] = $defaultColumnWidth;
                                        }
                                }
                        }
                }
                $image_compression = intval($this->cObj->stdWrap($conf['image_compression'],$conf['image_compression.']));
                $image_effects = intval($this->cObj->stdWrap($conf['image_effects'],$conf['image_effects.']));
                $image_frames = intval($this->cObj->stdWrap($conf['image_frames.']['key'],$conf['image_frames.']['key.']));

                        // EqualHeight
                $equalHeight = intval($this->cObj->stdWrap($conf['equalH'],$conf['equalH.']));
                if ($equalHeight)       {
                                // Initiate gifbuilder object in order to get dimensions AND calculate the imageWidth's
                        $gifCreator = t3lib_div::makeInstance('tslib_gifbuilder');
                        $gifCreator->init();
                        $relations_cols = Array();
                        for ($a=0; $a<$imgCount; $a++)  {
                                $imgKey = $a+$imgStart;
                                $imgInfo = $gifCreator->getImageDimensions($imgPath.$imgs[$imgKey]);
                                $rel = $imgInfo[1] / $equalHeight;      // relationship between the original height and the wished height
                                if ($rel)       {       // if relations is zero, then the addition of this value is omitted as the image is not expected to display because of some error.
                                        $relations_cols[floor($a/$colCount)] += $imgInfo[0]/$rel;       // counts the total width of the row with the new height taken into consideration.
                                }
                        }
                }

                        // Fetches pictures
                $splitArr = array();
                $splitArr['imgObjNum'] = $conf['imgObjNum'];
                $splitArr = $GLOBALS['TSFE']->tmpl->splitConfArray($splitArr, $imgCount);

                $imageRowsFinalWidths = Array();        // contains the width of every image row
                $imgsTag = array();
                $origImages = array();
                for ($a=0; $a<$imgCount; $a++)  {
                        $imgKey = $a+$imgStart;
                        $totalImagePath = $imgPath.$imgs[$imgKey];

                        $GLOBALS['TSFE']->register['IMAGE_NUM'] = $a;
                        $GLOBALS['TSFE']->register['ORIG_FILENAME'] = $totalImagePath;

                        $this->cObj->data[$this->cObj->currentValKey] = $totalImagePath;
                        $imgObjNum = intval($splitArr[$a]['imgObjNum']);
                        $imgConf = $conf[$imgObjNum.'.'];

                        if ($equalHeight)       {
                                $scale = 1;
                                $totalMaxW = $defaultColumnWidth*$colCount;
                                $rowTotalMaxW = $relations_cols[floor($a/$colCount)];
                                if ($rowTotalMaxW > $totalMaxW) {
                                        $scale = $rowTotalMaxW / $totalMaxW;
                                }

                                        // transfer info to the imageObject. Please note, that
                                $imgConf['file.']['height'] = round($equalHeight/$scale);

                                        // other stuff will be calculated accordingly:
                                unset($imgConf['file.']['width']);
                                unset($imgConf['file.']['maxW']);
                                unset($imgConf['file.']['maxH']);
                                unset($imgConf['file.']['minW']);
                                unset($imgConf['file.']['minH']);
                                unset($imgConf['file.']['width.']);
                                unset($imgConf['file.']['maxW.']);
                                unset($imgConf['file.']['maxH.']);
                                unset($imgConf['file.']['minW.']);
                                unset($imgConf['file.']['minH.']);
                        } else {
                                $imgConf['file.']['maxW'] = $columnWidths[($a%$colCount)];
                        }

                        $titleInLink = $this->cObj->stdWrap($imgConf['titleInLink'], $imgConf['titleInLink.']);
                        $titleInLinkAndImg = $this->cObj->stdWrap($imgConf['titleInLinkAndImg'], $imgConf['titleInLinkAndImg.']);
                        $oldATagParms = $GLOBALS['TSFE']->ATagParams;
                        if ($titleInLink)       {
                                        // Title in A-tag instead of IMG-tag
                                $titleText = trim($this->cObj->stdWrap($imgConf['titleText'], $imgConf['titleText.']));
                                if ($titleText) {
                                                // This will be used by the IMAGE call later:
                                        $GLOBALS['TSFE']->ATagParams .= ' title="'. $titleText .'"';
                                }
                        }

                        if ($imgConf || $imgConf['file'])       {
                                if ($this->cObj->image_effects[$image_effects]) {
                                        $imgConf['file.']['params'] .= ' '.$this->cObj->image_effects[$image_effects];
                                }
                                if ($image_frames)      {
                                        if (is_array($conf['image_frames.'][$image_frames.'.']))        {
                                                $imgConf['file.']['m.'] = $conf['image_frames.'][$image_frames.'.'];
                                        }
                                }
                                if ($image_compression && $imgConf['file'] != 'GIFBUILDER')     {
                                        if ($image_compression == 1)    {
                                                $tempImport = $imgConf['file.']['import'];
                                                $tempImport_dot = $imgConf['file.']['import.'];
                                                unset($imgConf['file.']);
                                                $imgConf['file.']['import'] = $tempImport;
                                                $imgConf['file.']['import.'] = $tempImport_dot;
                                        } elseif (isset($this->cObj->image_compression[$image_compression])) {
                                                $imgConf['file.']['params'] .= ' '.$this->cObj->image_compression[$image_compression]['params'];
                                                $imgConf['file.']['ext'] = $this->cObj->image_compression[$image_compression]['ext'];
                                                unset($imgConf['file.']['ext.']);
                                        }
                                }
                                if ($titleInLink && ! $titleInLinkAndImg)       {
                                                // Check if the image will be linked
                                        $link = $this->cObj->imageLinkWrap('', $totalImagePath, $imgConf['imageLinkWrap.']);
                                        if ($link)      {
                                                        // Title in A-tag only (set above: ATagParams), not in IMG-tag
                                                unset($imgConf['titleText']);
                                                unset($imgConf['titleText.']);
                                                $imgConf['emptyTitleHandling'] = 'removeAttr';
                                        }
                                }
                                $imgsTag[$imgKey] = $this->cObj->IMAGE($imgConf);
                        } else {
                                $imgsTag[$imgKey] = $this->cObj->IMAGE(Array('file' => $totalImagePath));       // currentValKey !!!
                        }
                                // Restore our ATagParams
                        $GLOBALS['TSFE']->ATagParams = $oldATagParms;
                                // Store the original filepath
                        $origImages[$imgKey] = $GLOBALS['TSFE']->lastImageInfo;

                        $imageRowsFinalWidths[floor($a/$colCount)] += $GLOBALS['TSFE']->lastImageInfo[0];
                }
                        // How much space will the image-block occupy?
                $imageBlockWidth = max($imageRowsFinalWidths)+ $colspacing*($colCount-1) + $colCount*$border*($borderSpace+$borderThickness)*2;
                $GLOBALS['TSFE']->register['rowwidth'] = $imageBlockWidth;

                        // noRows is in fact just one ROW, with the amount of columns specified, where the images are placed in.
                        // noCols is just one COLUMN, each images placed side by side on each row
                $noRows = $this->cObj->stdWrap($conf['noRows'],$conf['noRows.']);
                $noCols = $this->cObj->stdWrap($conf['noCols'],$conf['noCols.']);
                if ($noRows) {$noCols=0;}       // noRows overrides noCols. They cannot exist at the same time.

                $rowCount_temp = 1;
                $colCount_temp = $colCount;
                if ($noRows)    {
                        $rowCount_temp = $rowCount;
                        $rowCount = 1;
                }
                if ($noCols)    {
                        $colCount = 1;
                        $columnWidths = array();
                }

                        // Edit icons:
                $editIconsHTML = $conf['editIcons']&&$GLOBALS['TSFE']->beUserLogin ? $this->cObj->editIcons('',$conf['editIcons'],$conf['editIcons.']) : '';

                        // If noRows, we need multiple imagecolumn wraps
                $imageWrapCols = 1;
                if ($noRows)    { $imageWrapCols = $colCount; }

                        // User wants to separate the rows, but only do that if we do have rows
                $separateRows = $this->cObj->stdWrap($conf['separateRows'], $conf['separateRows.']);
                if ($noRows)    { $separateRows = 0; }
                if ($rowCount == 1)     { $separateRows = 0; }

                        // Apply optionSplit to the list of classes that we want to add to each image
                $addClassesImage = $conf['addClassesImage'];
                if ($conf['addClassesImage.'])  {
                        $addClassesImage = $this->cObj->stdWrap($addClassesImageConf, $conf['addClassesImage.']);
                }
                $addClassesImageConf = $GLOBALS['TSFE']->tmpl->splitConfArray(array('addClassesImage' => $addClassesImage), $colCount);

                        // Render the images
                $images = '';
                for ($c = 0; $c < $imageWrapCols; $c++) {
                        $tmpColspacing = $colspacing;
                        if (($c==$imageWrapCols-1 && $imagePosition==2) || ($c==0 && $imagePosition==1)) {
                                $tmpColspacing = 0;
                        }
                        $GLOBALS['TSFE']->register['columnwidth'] = $columnWidths[$c] + $tmpColspacing + $border*($borderSpace+$borderThickness)*2;
                        $thisImages = '';
                        $allRows = '';
                        for ($i = $c; $i<count($imgsTag); $i=$i+$imageWrapCols) {
                                $colPos = $i%$colCount;
                                if ($separateRows && $colPos == 0) {
                                        $thisRow = '';
                                }

                                        // Render one image
                                $GLOBALS['TSFE']->register['IMAGE_NUM'] = $i;
                                $GLOBALS['TSFE']->register['ORIG_FILENAME'] = $origImages[$i]['origFile'];
                                $GLOBALS['TSFE']->register['imagewidth'] = $origImages[$i][0];
                                $GLOBALS['TSFE']->register['imagespace'] = $origImages[$i][0] + $border*($borderSpace+$borderThickness)*2;
                                $GLOBALS['TSFE']->register['imageheight'] = $origImages[$i][1];

                                $thisImage = '';
                                $thisImage .= $this->cObj->stdWrap($imgsTag[$i], $conf['imgTagStdWrap.']);

                                if ($conf['captionSplit'] || $conf['imageTextSplit'])   {
                                        $thisImage .= $this->cObj->stdWrap($this->cObj->cObjGet($conf['caption.'], 'caption.'), $conf['caption.']);
                                }
                                if ($editIconsHTML)     {
                                        $thisImage .= $this->cObj->stdWrap($editIconsHTML, $conf['editIconsStdWrap.']);
                                }
                                if ($conf['netprintApplicationLink'])   {
                                        $thisImage .= $this->cObj->netprintApplication_offsiteLinkWrap($thisImage, $origImages[$i], $conf['netprintApplicationLink.']);
                                }
                                $thisImage = $this->cObj->stdWrap($thisImage, $conf['oneImageStdWrap.']);
                                $classes = '';
                                if ($addClassesImageConf[$colPos]['addClassesImage'])   {
                                        $classes = ' ' . $addClassesImageConf[$colPos]['addClassesImage'];
                                }
                                $thisImage = str_replace('###CLASSES###', $classes, $thisImage);

                                if ($separateRows)      {
                                        $thisRow .= $thisImage;
                                } else {
                                        $allRows .= $thisImage;
                                }
                                if ($separateRows && ($colPos == ($colCount-1) || $i+1==count($imgsTag)))       {
                                        // Close this row at the end (colCount), or the last row at the final end
                                        $allRows .= $this->cObj->stdWrap($thisRow, $conf['imageRowStdWrap.']);
                                }
                        }
                        if ($separateRows)      {
                                $thisImages .= $allRows;
                        } else {
                                $thisImages .= $this->cObj->stdWrap($allRows, $conf['noRowsStdWrap.']);
                        }
                        if ($noRows)    {
                                        // Only needed to make columns, rather than rows:
                                $images .= $this->cObj->stdWrap($thisImages, $conf['imageColumnStdWrap.']);
                        } else {
                                $images .= $thisImages;
                        }
                }

                        // Add the global caption, if not split
                if ($caption)   {
                        $images .= $caption;
                }

                        // CSS-classes
                $captionClass = '';
                $classCaptionAlign = array(
                        'center' => 'csc-textpic-caption-c',
                        'right' => 'csc-textpic-caption-r',
                        'left' => 'csc-textpic-caption-l',
                );
                $captionAlign = $this->cObj->stdWrap($conf['captionAlign'], $conf['captionAlign.']);
                if ($captionAlign)      {
                        $captionClass = $classCaptionAlign[$captionAlign];
                }
                $borderClass = '';
                if ($border)    {
                        $borderClass = 'csc-textpic-border';
                }

                        // Multiple classes with all properties, to be styled in CSS
                $class = '';
                $class .= ($borderClass? ' '.$borderClass:'');
                $class .= ($captionClass? ' '.$captionClass:'');
                $class .= ($equalHeight? ' csc-textpic-equalheight':'');
                $addClasses = $this->cObj->stdWrap($conf['addClasses'], $conf['addClasses.']);
                $class .= ($addClasses ? ' '.$addClasses:'');

                        // Do we need a width in our wrap around images?
                $imgWrapWidth = '';
                if ($position == 0 || $position == 8)   {
                                // For 'center' we always need a width: without one, the margin:auto trick won't work
                        $imgWrapWidth = $imageBlockWidth;
                }
                if ($rowCount > 1)      {
                                // For multiple rows we also need a width, so that the images will wrap
                        $imgWrapWidth = $imageBlockWidth;
                }
                if ($caption)   {
                                // If we have a global caption, we need the width so that the caption will wrap
                        $imgWrapWidth = $imageBlockWidth;
                }

                        // Wrap around the whole image block
                $GLOBALS['TSFE']->register['totalwidth'] = $imgWrapWidth;
                if ($imgWrapWidth)      {
                        $images = $this->cObj->stdWrap($images, $conf['imageStdWrap.']);
                } else {
                        $images = $this->cObj->stdWrap($images, $conf['imageStdWrapNoWidth.']);
                }

                $output = $this->cObj->cObjGetSingle($conf['layout'], $conf['layout.']);
                $output = str_replace('###TEXT###', $content, $output);
                $output = str_replace('###IMAGES###', $images, $output);
                $output = str_replace('###CLASSES###', $class, $output);

                if ($conf['stdWrap.'])  {
                        $output = $this->cObj->stdWrap($output, $conf['stdWrap.']);
                }

                return $output;
        }












        /************************************
         *
         * Helper functions
         *
         ************************************/

        function getTableAttributes($conf,$type)        {

                        // Initializing:
                $tableTagParams_conf = $conf['tableParams_'.$type.'.'];

                $conf['color.'][200] = '';
                $conf['color.'][240] = 'black';
                $conf['color.'][241] = 'white';
                $conf['color.'][242] = '#333333';
                $conf['color.'][243] = 'gray';
                $conf['color.'][244] = 'silver';

                        // Create table attributes array:
                $tableTagParams = array();
                $tableTagParams['border'] =  $this->cObj->data['table_border'] ? intval($this->cObj->data['table_border']) : $tableTagParams_conf['border'];
                $tableTagParams['cellspacing'] =  $this->cObj->data['table_cellspacing'] ? intval($this->cObj->data['table_cellspacing']) : $tableTagParams_conf['cellspacing'];
                $tableTagParams['cellpadding'] =  $this->cObj->data['table_cellpadding'] ? intval($this->cObj->data['table_cellpadding']) : $tableTagParams_conf['cellpadding'];
                $tableTagParams['bgcolor'] =  isset($conf['color.'][$this->cObj->data['table_bgColor']]) ? $conf['color.'][$this->cObj->data['table_bgColor']] : $conf['color.']['default'];

                        // Return result:
                return $tableTagParams;
        }

        function &hookRequest($functionName)    {
                global $TYPO3_CONF_VARS;

                        // Hook: menuConfig_preProcessModMenu
                if ($TYPO3_CONF_VARS['EXTCONF']['css_styled_content']['pi1_hooks'][$functionName]) {
                        $hookObj = &t3lib_div::getUserObj($TYPO3_CONF_VARS['EXTCONF']['css_styled_content']['pi1_hooks'][$functionName]);
                        if (method_exists ($hookObj, $functionName)) {
                                $hookObj->pObj = &$this;
                                return $hookObj;
                        }
                }
        }
}



if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['ext/css_styled_content/pi1/class.tx_cssstyledcontent_pi1.php'])    {
        include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['ext/css_styled_content/pi1/class.tx_cssstyledcontent_pi1.php']);
}
?>

---