TYPO3 Core

/**

* stdWrap functions in their correct order

*

* @see stdWrap()

*/

var $stdWrapOrder = array(

'stdWrapPreProcess' => 1, // this is a placeholder for the first Hook

'setContentToCurrent' => 1,

'setContentToCurrent.' => 1,

'setCurrent' => 1,

'setCurrent.' => 1,

'lang' => 1,

'lang.' => 1,

'data' => 1,

'data.' => 1,

'field' => 1,

'field.' => 1,

'current' => 1,

'current.' => 1,

'cObject' => 1,

'cObject.' => 1,

'numRows' => 1,

'numRows.' => 1,

'filelist' => 1,

'filelist.' => 1,

'preUserFunc' => 1,

'preUserFunc.' => 1,

'stdWrapOverride' => 1, // this is a placeholder for the second Hook

'override' => 1,

'override.' => 1,

'preIfEmptyListNum' => 1,

'preIfEmptyListNum.' => 1,

'ifEmpty' => 1,

'ifEmpty.' => 1,

'ifBlank' => 1,

'ifBlank.' => 1,

'listNum' => 1,

'listNum.' => 1,

'trim' => 1,

'trim.' => 1,

'stdWrap' => 1,

'stdWrap.' => 1,

'stdWrapProcess' => 1, // this is a placeholder for the third Hook

'required' => 1,

'required.' => 1,

'if' => 1,

'if.' => 1,

'fieldRequired' => 1,

'fieldRequired.' => 1,

'csConv' => 1,

'csConv.' => 1,

'parseFunc' => 1,

'parseFunc.' => 1,

'HTMLparser' => 1,

'HTMLparser.' => 1,

'split' => 1,

'split.' => 1,

'prioriCalc' => 1,

'prioriCalc.' => 1,

'char' => 1,

'char.' => 1,

'intval' => 1,

'intval.' => 1,

'numberFormat' => 1,

'numberFormat.' => 1,

'date' => 1,

'date.' => 1,

'strftime' => 1,

'strftime.' => 1,

'age' => 1,

'age.' => 1,

'case' => 1,

'case.' => 1,

'bytes' => 1,

'bytes.' => 1,

'substring' => 1,

'substring.' => 1,

'removeBadHTML' => 1,

'removeBadHTML.' => 1,

'cropHTML' => 1,

'cropHTML.' => 1,

'stripHtml' => 1,

'stripHtml.' => 1,

'crop' => 1,

'crop.' => 1,

'rawUrlEncode' => 1,

'rawUrlEncode.' => 1,

'htmlSpecualChars' => 1,

'htmlSpecualChars.' => 1,

'doubleBrTag' => 1,

'doubleBrTag.' => 1,

'br' => 1,

'br.' => 1,

'brTag' => 1,

'brTag.' => 1,

'encapsLines' => 1,

'encapsLines.' => 1,

'keywords' => 1,

'keywords.' => 1,

'innerWrap' => 1,

'innerWrap.' => 1,

'innerWrap2' => 1,

'innerWrap2.' => 1,

'fontTag' => 1,

'fontTag.' => 1,

'addParams' => 1,

'addParams.' => 1,

'textStyle' => 1,

'textStyle.' => 1,

'tableStyle' => 1,

'tableStyle.' => 1,

'filelink' => 1,

'filelink.' => 1,

'preCObject' => 1,

'preCObject.' => 1,

'postCObject' => 1,

'postCObject.' => 1,

'wrapAlign' => 1,

'wrapAlign.' => 1,

'typolink' => 1,

'typolink.' => 1,

'TCAselectItem' => 1,

'TCAselectItem.' => 1,

'space' => 1,

'space.' => 1,

'spaceBefore' => 1,

'spaceBefore.' => 1,

'spaceAfter' => 1,

'spaceAfter.' => 1,

'wrap' => 1,

'wrap.' => 1,

'noTrimWrap' => 1,

'noTrimWrap.' => 1,

'wrap2' => 1,

'wrap2.' => 1,

'dataWrap' => 1,

'dataWrap.' => 1,

'prepend' => 1,

'prepend.' => 1,

'append' => 1,

'append.' => 1,

'wrap3' => 1,

'wrap3.' => 1,

'outerWrap' => 1,

'outerWrap.' => 1,

'insertData' => 1,

'insertData.' => 1,

'offsetWrap' => 1,

'offsetWrap.' => 1,

'postUserFunc' => 1,

'postUserFunc.' => 1,

'postUserFuncInt' => 1,

'postUserFuncInt.' => 1,

'prefixComment' => 1,

'prefixComment.' => 1,

'editIcons' => 1,

'editIcons.' => 1,

'editPanel' => 1,

'editPanel.' => 1,

'stdWrapPostProcess' => 1, // this is a placeholder for the last Hook

'debug' => 1,

'debug.' => 1,

'debugFunc' => 1,

'debugFunc.' => 1,

'debugData' => 1,

'debugData.' => 1

);

// Substitution/Merging:

// Merging content types together, resetting

$valueArr = array_merge($markContentArray, $subpartContentArray, $wrappedSubpartContentArray);

$wSCA_reg = array();

$content = '';

// traversing the keyList array and merging the static and dynamic content

foreach ($storeArr['k'] as $n => $keyN) {

$content .= $storeArr['c'][$n];

if (!is_array($valueArr[$keyN])) {

$content .= $valueArr[$keyN];

} else {

$content .= $valueArr[$keyN][(intval($wSCA_reg[$keyN]) % 2)];

$wSCA_reg[$keyN]++;

}

}

$content .= $storeArr['c'][count($storeArr['k'])];

$GLOBALS['TT']->pull();

return $content;

}

/**

* Traverses the input $markContentArray array and for each key the marker

* by the same name (possibly wrapped and in upper case) will be

* substituted with the keys value in the array.

*

* This is very useful if you have a data-record to substitute in some

* content. In particular when you use the $wrap and $uppercase values to

* pre-process the markers. Eg. a key name like "myfield" could effectively

* be represented by the marker "###MYFIELD###" if the wrap value

* was "###|###" and the $uppercase boolean TRUE.

*

* @param string The content stream, typically HTML template content.

* @param array The array of key/value pairs being marker/content values used in the substitution. For each element in this array the function will substitute a marker in the content stream with the content.

* @param string A wrap value - [part 1] | [part 2] - for the markers before substitution

* @param boolean If set, all marker string substitution is done with upper-case markers.

* @param boolean If set, all unused marker are deleted.

* @return string The processed output stream

* @see substituteMarker(), substituteMarkerInObject(), TEMPLATE()

*/

public function substituteMarkerArray($content, array $markContentArray, $wrap = '', $uppercase = FALSE, $deleteUnused = FALSE) {

return t3lib_parsehtml::substituteMarkerArray($content, $markContentArray, $wrap, $uppercase, $deleteUnused);

}

/**

* Substitute marker array in an array of values

*

* @param mixed If string, then it just calls substituteMarkerArray. If array(and even multi-dim) then for each key/value pair the marker array will be substituted (by calling this function recursively)

* @param array The array of key/value pairs being marker/content values used in the substitution. For each element in this array the function will substitute a marker in the content string/array values.

* @return mixed The processed input variable.

* @see substituteMarker()

*/

public function substituteMarkerInObject(&$tree, array $markContentArray) {

if (is_array($tree)) {

foreach ($tree as $key => $value) {

$this->substituteMarkerInObject($tree[$key], $markContentArray);

}

} else {

$tree = $this->substituteMarkerArray($tree, $markContentArray);

}

return $tree;

}

/**

* Adds elements to the input $markContentArray based on the values from

* the fields from $fieldList found in $row

*

* @param array array with key/values being marker-strings/substitution values.

* @param array An array with keys found in the $fieldList (typically a record) which values should be moved to the $markContentArray

* @param string A list of fields from the $row array to add to the $markContentArray array. If empty all fields from $row will be added (unless they are integers)

* @param boolean If set, all values added to $markContentArray will be nl2br()'ed

* @param string Prefix string to the fieldname before it is added as a key in the $markContentArray. Notice that the keys added to the $markContentArray always start and end with "###"

* @param boolean If set, all values are passed through htmlspecialchars() - RECOMMENDED to avoid most obvious XSS and maintain XHTML compliance.

* @return array The modified $markContentArray

*/

public function fillInMarkerArray(array $markContentArray, array $row, $fieldList = '', $nl2br = TRUE, $prefix = 'FIELD_', $HSC = FALSE) {

if ($fieldList) {

$fArr = t3lib_div::trimExplode(',', $fieldList, 1);

foreach ($fArr as $field) {

$markContentArray['###' . $prefix . $field . '###'] = $nl2br ? nl2br($row[$field]) : $row[$field];

}

} else {

if (is_array($row)) {

foreach ($row as $field => $value) {

if (!t3lib_div::testInt($field)) {

if ($HSC) {

$value = htmlspecialchars($value);

}

$markContentArray['###' . $prefix . $field . '###'] = $nl2br ? nl2br($value) : $value;

}

}

}

}

return $markContentArray;

}

/***********************************************

*

* "stdWrap" + sub functions

*

***********************************************/

/**

* The "stdWrap" function. This is the implementation of what is known as "stdWrap properties" in TypoScript.

* Basically "stdWrap" performs some processing of a value based on properties in the input $conf array(holding the TypoScript "stdWrap properties")

* See the link below for a complete list of properties and what they do. The order of the table with properties found in TSref (the link) follows the actual order of implementation in this function.

*

* If $this->alternativeData is an array it's used instead of the $this->data array in ->getData

*

* @param string Input value undergoing processing in this function. Possibly substituted by other values fetched from another source.

* @param array TypoScript "stdWrap properties".

* @return string The processed input value

* @link http://typo3.org/doc.0.html?&tx_extrepmgm_pi1[extUid]=270&tx_extrepmgm_pi1[tocEl]=314&cHash=02ab044c7b

*/

function stdWrap($content = '', $conf = array()) {

if(count($this->stdWrapHookObjects)) {

foreach ($this->stdWrapHookObjects as $hookObject) {

if(is_callable($hookObject->stdWrapPreProcess)) {

$conf['stdWrapPreProcess'] = 'stdWrapHookObject';

};

if(is_callable($hookObject->stdWrapOverride)) {

$conf['stdWrapOverride'] = 'stdWrapHookObject';

};

if(is_callable($hookObject->stdWrapProcess)) {

$conf['stdWrapProcess'] = 'stdWrapHookObject';

};

if(is_callable($hookObject->stdWrapPostProcess)) {

$conf['stdWrapPostProcess'] = 'stdWrapHookObject';

};

}

}

if (count($conf)) {

// check, which of the available stdWrap functions is needed for the current conf Array

// and keep only those but still in the same order

$sortedConf = array_intersect_key($this->stdWrapOrder,$conf);

// functions that should not make use of nested stdWrap function calls to avoid conflicts with internal TypoScript used by these functions

$stdWrapDisabledFunctions = 'cObject,preUserFunc,stdWrap,preCObject,postCObject,prepend,append,postUserFunc,postUserFuncInt';

// additional Array to check whether a function has already been executed

$isExecuted = array();

// additional switch to make sure 'required', 'if' and 'fieldRequired'

// will still stop rendering immediately in case they return false

$this->stopRendering = false;

// execute each funtion in the predefined order

foreach($sortedConf as $stdWrapName => $enabled) {

// eliminate the second key of a pair 'key'|'key.' to make sure functions get called only once and check if rendering has been stopped

if(!$isExecuted[$stdWrapName] && !$this->stopRendering) {

$functionName = rtrim($stdWrapName,'.');

$functionProperties = $functionName.'.';

// if there is any code one the next level, check if it contains "official" stdWrap functions

// if yes, execute them first - will make each function stdWrap aware

// so additional stdWrap calls within the functions can be removed, since the result will be the same

// exception: the recursive stdWrap function and cObject will still be using their own stdWrap call, since it modifies the content and not a property

if( count($conf[$functionProperties]) &&

!t3lib_div::inList($stdWrapDisabledFunctions,$functionName)) {

if(array_intersect_key($this->stdWrapOrder,$conf[$functionProperties])) {

$conf[$functionName] = $this->stdWrap($conf[$functionName],$conf[$functionProperties]);

}

}

// get just that part of $conf that is needed for the particular function

$singleConf = array(

$functionName => $conf[$functionName],

$functionProperties => $conf[$functionProperties]

);

// in this special case 'spaceBefore' and 'spaceAfter' need additional stuff from 'space.''

if($functionName == 'spaceBefore' || $functionName == 'spaceAfter') {

$singleConf['space.'] = $conf['space.'];

}

// hand over the whole $conf array to the stdWrapHookObjects

if($conf[$functionName] == 'stdWrapHookObject') {

$singleConf = $conf;

}

// check if key is still containing something, since it might have been changed by next level stdWrap before

if($conf[$functionName] || $conf[$functionProperties]) {

//add both keys - with and without the dot - to the set of executed functions

$isExecuted[$functionName] = true;

$isExecuted[$functionProperties] = true;

// call the function with the prefix stdWrap_ to make sure nobody can execute functions just by adding their name to the TS Array

$functionName = 'stdWrap_'.$functionName;

$content = $this->$functionName(

$content,

$singleConf

);

}

}

}

}

return $content;

}

/**

* stdWrap pre process hook

* can be used by extensions authors to modify the behaviour of stdWrap functions to their needs

* this hook will execute functions before any other stdWrap function can modify anything

*

* @param string Input value undergoing processing in these functions.

* @param array All stdWrap properties, not just the ones for a particular function.

* @return string The processed input value

*/

function stdWrap_stdWrapPreProcess($content = '', $conf = array()) {

foreach ($this->stdWrapHookObjects as $hookObject) {

$content = $hookObject->stdWrapPreProcess($content, $conf, $this);

}

return $content;

}

/**

* setContentToCurrent

* actually it just does the contrary: Sets the value of 'current' based on current content

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for setContentToCurrent.

* @return string The processed input value

*/

function stdWrap_setContentToCurrent($content = '', $conf = array()) {

$this->data[$this->currentValKey] = $content;

}

/**

* setCurrent

* Sets the value of 'current' based on the outcome of stdWrap operations

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for setCurrent.

* @return string The processed input value

*/

function stdWrap_setCurrent($content = '', $conf = array()) {

$this->data[$this->currentValKey] = $conf['setCurrent'];

}

/**

* lang

* Translates content based on the language currently used by the FE

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for lang.

* @return string The processed input value

*/

function stdWrap_lang($content = '', $conf = array()) {

if (isset($conf['lang.']) && $GLOBALS['TSFE']->config['config']['language'] && isset($conf['lang.'][$GLOBALS['TSFE']->config['config']['language']])) {

$content = $conf['lang.'][$GLOBALS['TSFE']->config['config']['language']];

}

return $content;

}

/**

* data

* Gets content from different sources based on getText functions, makes use of alternativeData, when set

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for data.

* @return string The processed input value

*/

function stdWrap_data($content = '', $conf = array()) {

$content = $this->getData($conf['data'], is_array($this->alternativeData) ? $this->alternativeData : $this->data);

$this->alternativeData = ''; // This must be unset directly after

return $content;

}

/**

* field

* Gets content from a DB field

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for field.

* @return string The processed input value

*/

function stdWrap_field($content = '', $conf = array()) {

$content = $this->getFieldVal($conf['field']);

return $content;

}

/**

* current

* Gets content that has been perviously set as 'current'

* Can be set via setContentToCurrent or setCurrent or will be set automatically i.e. inside the split function

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for current.

* @return string The processed input value

*/

function stdWrap_current($content = '', $conf = array()) {

$content = $this->data[$this->currentValKey];

return $content;

}

/**

* cObject

* Will replace the content with the value of a any official TypoScript cObject

* like TEXT, COA, HMENU

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for cObject.

* @return string The processed input value

*/

function stdWrap_cObject($content = '', $conf = array()) {

$content = $this->cObjGetSingle($conf['cObject'], $conf['cObject.'], '/stdWrap/.cObject');

return $content;

}

/**

* numRows

* Counts the number of returned records of a DB operation

* makes use of select internally

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for numRows.

* @return string The processed input value

*/

function stdWrap_numRows($content = '', $conf = array()) {

$content = $this->numRows($conf['numRows.']);

return $content;

}

/**

* filelist

* Will create a list of files based on some additional parameters

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for filelist.

* @return string The processed input value

*/

function stdWrap_filelist($content = '', $conf = array()) {

$content = $this->filelist($conf['filelist']);

return $content;

}

/**

* preUserFunc

* Will execute a user function before the content will be modified by any other stdWrap function

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for preUserFunc.

* @return string The processed input value

*/

function stdWrap_preUserFunc($content = '', $conf = array()) {

$content = $this->callUserFunction($conf['preUserFunc'], $conf['preUserFunc.'], $content);

return $content;

}

/**

* stdWrap override hook

* can be used by extensions authors to modify the behaviour of stdWrap functions to their needs

* this hook will execute functions on existing content but still before the content gets modified or replaced

*

* @param string Input value undergoing processing in these functions.

* @param array All stdWrap properties, not just the ones for a particular function.

* @return string The processed input value

*/

function stdWrap_stdWrapOverride($content = '', $conf = array()) {

foreach ($this->stdWrapHookObjects as $hookObject) {

$content = $hookObject->stdWrapOverride($content, $conf, $this);

}

return $content;

}

/**

* override

* Will override the current value of content with its own value'

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for override.

* @return string The processed input value

*/

function stdWrap_override($content = '', $conf = array()) {

if (trim($conf['override'])) {

$content = $conf['override'];

}

return $content;

}

/**

* preIfEmptyListNum

* Gets a value off a CSV list before the following ifEmpty check

* Makes sure that the result of ifEmpty will be true in case the CSV does not contain a value at the position given by preIfEmptyListNum

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for preIfEmptyListNum.

* @return string The processed input value

*/

function stdWrap_preIfEmptyListNum($content = '', $conf = array()) {

$content = $this->listNum($content, $conf['preIfEmptyListNum'], $conf['preIfEmptyListNum.']['splitChar']);

return $content;

}

/**

* ifEmpty

* Will set content to a replacement value in case the trimmed value of content returns false

* 0 (zero) will be replaced as well

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for ifEmpty.

* @return string The processed input value

*/

function stdWrap_ifEmpty($content = '', $conf = array()) {

if (!trim($content)) {

$content = $conf['ifEmpty'];

}

return $content;

}

/**

* ifBlank

* Will set content to a replacement value in case the trimmed value of content has no length

* 0 (zero) will not be replaced

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for ifBlank.

* @return string The processed input value

*/

function stdWrap_ifBlank($content = '', $conf = array()){

if (!strlen(trim($content))) {

$content = $conf['ifBlank'];

}

return $content;

}

/**

* listNum

* Gets a value off a CSV list after ifEmpty check

* Might return an empty value in case the CSV does not contain a value at the position given by listNum

* Use preIfEmptyListNum to avoid that behaviour

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for listNum.

* @return string The processed input value

*/

function stdWrap_listNum($content = '', $conf = array()) {

$content = $this->listNum($content, $conf['listNum'], $conf['listNum.']['splitChar']);

return $content;

}

/**

* trim

* Cuts off any whitespace at the beginning and the end of the content

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for trim.

* @return string The processed input value

*/

function stdWrap_trim($content = '', $conf = array()) {

$content = trim($content);

return $content;

}

/**

* stdWrap

* A recursive call of the stdWrap function set

* This enables the user to execute stdWrap functions in another than the predefined order

* It modifies the content, not the property

* while the new feature of chained stdWrap functions modifies the property and not the content

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for stdWrap.

* @return string The processed input value

*/

function stdWrap_stdWrap($content = '', $conf = array()) {

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

return $content;

}

/**

* stdWrap process hook

* can be used by extensions authors to modify the behaviour of stdWrap functions to their needs

* this hook executes functions directly after the recursive stdWrap function call but still before the content gets modified

*

* @param string Input value undergoing processing in these functions.

* @param array All stdWrap properties, not just the ones for a particular function.

* @return string The processed input value

*/

function stdWrap_stdWrapProcess($content = '', $conf = array()) {

foreach ($this->stdWrapHookObjects as $hookObject) {

$content = $hookObject->stdWrapProcess($content, $conf, $this);

}

return $content;

}

/**

* required

* Will immediately stop rendering and return an empty value

* when there is no content at this point

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for required.

* @return string The processed input value

*/

function stdWrap_required($content = '', $conf = array()) {

if ((string) $content == '') {

$content = '';

$this->stopRendering = TRUE;

}

return $content;

}

/**

* if

* Will immediately stop rendering and return an empty value

* when the result of the checks returns false

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for if.

* @return string The processed input value

*/

function stdWrap_if($content = '', $conf = array()) {

if (!$this->checkIf($conf['if.'])) {

$content = '';

$this->stopRendering = TRUE;

}

return $content;

}

/**

* fieldRequired

* Will immediately stop rendering and return an empty value

* when there is no content in the field given by fieldRequired

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for fieldRequired.

* @return string The processed input value

*/

function stdWrap_fieldRequired($content = '', $conf = array()) {

if (!trim($this->data[$conf['fieldRequired']])) {

$content = '';

$this->stopRendering = TRUE;

}

return $content;

}

/**

* csConv

* Will convert the current chracter set of the content to the one given in csConv

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for csConv.

* @return string The processed input value

*/

function stdWrap_csConv($content = '', $conf = array()) {

$content = $GLOBALS['TSFE']->csConv($content, $conf['csConv']);

return $content;

}

/**

* parseFunc

* Will parse the content based on functions given as stdWrap properties

* Heavily used together with RTE based content

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for parseFunc.

* @return string The processed input value

*/

function stdWrap_parseFunc($content = '', $conf = array()) {

$content = $this->parseFunc($content, $conf['parseFunc.'], $conf['parseFunc']);

return $content;

}

/**

* HTMLparser

* Will parse HTML content based on functions given as stdWrap properties

* Heavily used together with RTE based content

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for HTMLparser.

* @return string The processed input value

*/

function stdWrap_HTMLparser($content = '', $conf = array()) {

if (is_array($conf['HTMLparser.'])) {

$content = $this->HTMLparser_TSbridge($content, $conf['HTMLparser.']);

}

return $content;

}

/**

* split

* Will split the content by a given token and treat the results separately

* Automatically fills 'current' with a single result

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for split.

* @return string The processed input value

*/

function stdWrap_split($content = '', $conf = array()) {

$content = $this->splitObj($content, $conf['split.']);

return $content;

}

/**

* prioriCalc

* Will use the content as a mathematical term and calculate the result

* Can be set to 1 to just get a calculated value or 'intval' to get the integer of the result

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for prioriCalc.

* @return string The processed input value

*/

function stdWrap_prioriCalc($content = '', $conf = array()) {

$content = t3lib_div::calcParenthesis($content);

if ($conf['prioriCalc'] == 'intval')

$content = intval($content);

return $content;

}

/**

* char

* Will return a character based on its position within the current character set

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for char.

* @return string The processed input value

*/

function stdWrap_char($content = '', $conf = array()) {

$content = chr(intval($conf['char']));

return $content;

}

/**

* intval

* Will return an integer value of the current content

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for intval.

* @return string The processed input value

*/

function stdWrap_intval($content = '', $conf = array()) {

$content = intval($content);

return $content;

}

/**

* numberFormat

* Will return a formatted number based on configuration given as stdWrap properties

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for numberFormat.

* @return string The processed input value

*/

function stdWrap_numberFormat($content = '', $conf = array()) {

$content = $this->numberFormat($content, $conf['numberFormat.']);

return $content;

}

/**

* date

* Will return a formatted date based on configuration given according to PHP date/gmdate properties

* Will return gmdate when the property GMT returns true

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for date.

* @return string The processed input value

*/

function stdWrap_date($content = '', $conf = array()) {

$content = ($conf['date.']['GMT'] ? gmdate($conf['date'], $content) : date($conf['date'], $content));

return $content;

}

/**

* strftime

* Will return a formatted date based on configuration given according to PHP strftime/gmstrftime properties

* Will return gmstrftime when the property GMT returns true

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for strftime.

* @return string The processed input value

*/

function stdWrap_strftime($content = '', $conf = array()) {

$content = ($conf['strftime.']['GMT'] ? gmstrftime($conf['strftime'], $content) : strftime($conf['strftime'], $content));

$tmp_charset = $conf['strftime.']['charset'] ? $conf['strftime.']['charset'] : $GLOBALS['TSFE']->localeCharset;

if ($tmp_charset) {

$content = $GLOBALS['TSFE']->csConv($content, $tmp_charset);

}

return $content;

}

/**

* age

* Will return the age of a given timestamp based on configuration given by stdWrap properties

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for age.

* @return string The processed input value

*/

function stdWrap_age($content = '', $conf = array()) {

$content = $this->calcAge($GLOBALS['EXEC_TIME'] - $content, $conf['age']);

return $content;

}

/**

* case

* Will transform the content to be upper or lower case only

* Leaves HTML tags untouched

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for case.

* @return string The processed input value

*/

function stdWrap_case($content = '', $conf = array()) {

$content = $this->HTMLcaseshift($content, $conf['case']);

return $content;

}

/**

* bytes

* Will return the size of a given number in Bytes *

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for bytes.

* @return string The processed input value

*/

function stdWrap_bytes($content = '', $conf = array()) {

$content = t3lib_div::formatSize($content, $conf['bytes.']['labels']);

return $content;

}

/**

* substring

* Will return a substring based on position information given by stdWrap properties

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for substring.

* @return string The processed input value

*/

function stdWrap_substring($content = '', $conf = array()) {

$content = $this->substring($content, $conf['substring']);

return $content;

}

/**

* removeBadHTML

* Removes HTML tags based on stdWrap properties

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for removeBadHTML.

* @return string The processed input value

*/

function stdWrap_removeBadHTML($content = '', $conf = array()) {

$content = $this->removeBadHTML($content, $conf['removeBadHTML.']);

return $content;

}

/**

* cropHTML

* Crops content to a given size while leaving HTML tags untouched

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for cropHTML.

* @return string The processed input value

*/

function stdWrap_cropHTML($content = '', $conf = array()) {

$content = $this->cropHTML($content, $conf['cropHTML']);

return $content;

}

/**

* stripHtml

* Copmletely removes HTML tags from content

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for stripHtml.

* @return string The processed input value

*/

function stdWrap_stripHtml($content = '', $conf = array()) {

$content = strip_tags($content);

return $content;

}

/**

* cropHTML

* Crops content to a given size without caring abhout HTML tags

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for crop.

* @return string The processed input value

*/

function stdWrap_crop($content = '', $conf = array()) {

$content = $this->crop($content, $conf['crop']);

return $content;

}

/**

* rawUrlEncode

* Encodes content to be used within URLs

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for rawUrlEncode.

* @return string The processed input value

*/

function stdWrap_rawUrlEncode($content = '', $conf = array()) {

$content = rawurlencode($content);

return $content;

}

/**

* htmlSpecialChars

* Transforms HTML tags to readable text by replacing special characters with their HTML entity

* When preserveEntities returns true, existing entities will be left untouched

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for htmlSpecalChars.

* @return string The processed input value

*/

function stdWrap_htmlSpecialChars($content = '', $conf = array()) {

$content = htmlSpecialChars($content);

if ($conf['htmlSpecialChars.']['preserveEntities'])

$content = t3lib_div::deHSCentities($content);

return $content;

}

/**

* doubleBrTag

* Searches for double line breaks and replaces them with the given value

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for doubleBrTag.

* @return string The processed input value

*/

function stdWrap_doubleBrTag($content = '', $conf = array()) {

$content = preg_replace("/\r?\n[\t ]*\r?\n/", $conf['doubleBrTag'], $content);

return $content;

}

/**

* br

* Searches for single line breaks and replaces them with a <br /> tag

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for br.

* @return string The processed input value

*/

function stdWrap_br($content = '', $conf = array()) {

$content = nl2br($content);

return $content;

}

/**

* brTag

* Searches for single line feeds and replaces them with the given value

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for brTag.

* @return string The processed input value

*/

function stdWrap_brTag($content = '', $conf = array()) {

$content = str_replace(LF, $conf['brTag'], $content);

return $content;

}

/**

* encapsLines

* Modifies text blocks by searching for lines which are not surrounded by HTML tags yet

* and wrapping them with values given by stdWrap properties

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for erncapsLines.

* @return string The processed input value

*/

function stdWrap_encapsLines($content = '', $conf = array()) {

$content = $this->encaps_lineSplit($content, $conf['encapsLines.']);

return $content;

}

/**

* keywords

* Transforms content into a CSV list to be used i.e. as keywords within a meta tag

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for keywords.

* @return string The processed input value

*/

function stdWrap_keywords($content = '', $conf = array()) {

$content = $this->keywords($content);

return $content;

}

/**

* innerWrap

* First of a set of different wraps which will be applied in a certain order before or after other functions that modify the content

* See wrap

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for innerWrap.

* @return string The processed input value

*/

function stdWrap_innerWrap($content = '', $conf = array()) {

$content = $this->wrap($content, $conf['innerWrap']);

return $content;

}

/**

* innerWrap2

* Second of a set of different wraps which will be applied in a certain order before or after other functions that modify the content

* See wrap

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for innerWrap2.

* @return string The processed input value

*/

function stdWrap_innerWrap2($content = '', $conf = array()) {

$content = $this->wrap($content, $conf['innerWrap2']);

return $content;

}

/**

* fontTag

* A wrap formerly used to apply font tags to format the content

* Still used by lib.stdheader although real font tags are not state of the art anymore

* See wrap

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for fontTag.

* @return string The processed input value

*/

function stdWrap_fontTag($content = '', $conf = array()) {

$content = $this->wrap($content, $conf['fontTag']);

return $content;

}

/**

* addParams

* Adds tag attributes to any content that is a tag

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for addParams.

* @return string The processed input value

*/

function stdWrap_addParams($content = '', $conf = array()) {

$content = $this->addParams($content, $conf['addParams.']);

return $content;

}

/**

* textStyle

* Wraps content in font tags

* See wrap

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for textStyle.

* @return string The processed input value

*/

function stdWrap_textStyle($content = '', $conf = array()) {

$content = $this->textStyle($content, $conf['textStyle.']);

return $content;

}

/**

* tableStyle

* Wraps content with table tags

* See wrap

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for tableStyle.

* @return string The processed input value

*/

function stdWrap_tableStyle($content = '', $conf = array()) {

$content = $this->tableStyle($content, $conf['tableStyle.']);

return $content;

}

/**

* filelink

* Used to make lists of links to files

* See wrap

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for filelink.

* @return string The processed input value

*/

function stdWrap_filelink($content = '', $conf = array()) {

$content = $this->filelink($content, $conf['filelink.']);

return $content;

}

/**

* preCObject

* A content object that is prepended to the current content but between the innerWraps and the rest of the wraps

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for preCObject.

* @return string The processed input value

*/

function stdWrap_preCObject($content = '', $conf = array()) {

$content = $this->cObjGetSingle($conf['preCObject'], $conf['preCObject.'], '/stdWrap/.preCObject') . $content;

return $content;

}

/**

* postCObject

* A content object that is appended to the current content but between the innerWraps and the rest of the wraps

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for postCObject.

* @return string The processed input value

*/

function stdWrap_postCObject($content = '', $conf = array()) {

$content .= $this->cObjGetSingle($conf['postCObject'], $conf['postCObject.'], '/stdWrap/.postCObject');

return $content;

}

/**

* wrapAlign

* Wraps content with a div container having the style attribute text-align set to the given value

* See wrap

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for wrapAlign.

* @return string The processed input value

*/

function stdWrap_wrapAlign($content = '', $conf = array()) {

$wrapAlign = trim($conf['wrapAlign']);

if ($wrapAlign) {

$content = $this->wrap($content, '<div style="text-align:' . $wrapAlign . ';">|</div>');

}

return $content;

}

/**

* typolink

* Wraps the content with a link tag

* URLs and other attributes are created automatically by the values given in the stdWrap properties

* See wrap

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for typolink.

* @return string The processed input value

*/

function stdWrap_typolink($content = '', $conf = array()) {

$content = $this->typolink($content, $conf['typolink.']);

return $content;

}

/**

* TCAselectItem

* Returns a list of options available for a given field in the DB which has to be of the type select

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for TCAselectItem.

* @return string The processed input value

*/

function stdWrap_TCAselectItem($content = '', $conf = array()) {

if (is_array($conf['TCAselectItem.'])) {

$content = $this->TCAlookup($content, $conf['TCAselectItem.']);

}

return $content;

}

/**

* spaceBefore

* Will add space before the current content

* By default this is done with a clear.gif but it can be done with CSS margins by setting the property space.useDiv to true

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for spaceBefore and space.

* @return string The processed input value

*/

function stdWrap_spaceBefore($content = '', $conf = array()) {

$content = $this->wrapSpace($content, trim($conf['spaceBefore']) . '|', $conf['space.']);

return $content;

}

/**

* spaceAfter

* Will add space after the current content

* By default this is done with a clear.gif but it can be done with CSS margins by setting the property space.useDiv to true

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for spaceAfter and space.

* @return string The processed input value

*/

function stdWrap_spaceAfter($content = '', $conf = array()) {

$content = $this->wrapSpace($content, '|' . trim($conf['spaceAfter']), $conf['space.']);

return $content;

}

/**

* space

* Will add space before or after the current content

* By default this is done with a clear.gif but it can be done with CSS margins by setting the property space.useDiv to true

* See wrap

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for space.

* @return string The processed input value

*/

function stdWrap_space($content = '', $conf = array()) {

$content = $this->wrapSpace($content, trim($conf['space']), $conf['space.']);

return $content;

}

/**

* wrap

* This is the "mother" of all wraps

* Third of a set of different wraps which will be applied in a certain order before or after other functions that modify the content

* Basically it will put additional content before and after the current content using a split character as a placeholder for the current content

* The default split character is | but it can be replaced with other characters by the property splitChar

* Any other wrap that does not have own splitChar settings will be using the default split char though

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for wrap.

* @return string The processed input value

*/

function stdWrap_wrap($content = '', $conf = array()) {

$content = $this->wrap($content, $conf['wrap'], ($conf['wrap.']['splitChar'] ? $conf['wrap.']['splitChar'] : '|'));

return $content;

}

/**

* noTrimWrap

* Fourth of a set of different wraps which will be applied in a certain order before or after other functions that modify the content

* The major difference to any other wrap is, that this one can make use of whitespace without trimming *

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for noTrimWrap.

* @return string The processed input value

*/

function stdWrap_noTrimWrap($content = '', $conf = array()) {

$content = $this->noTrimWrap($content, $conf['noTrimWrap']);

return $content;

}

/**

* wrap2

* Fifth of a set of different wraps which will be applied in a certain order before or after other functions that modify the content

* The default split character is | but it can be replaced with other characters by the property splitChar

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for wrap2.

* @return string The processed input value

*/

function stdWrap_wrap2($content = '', $conf = array()) {

$content = $this->wrap($content, $conf['wrap2'], ($conf['wrap2.']['splitChar'] ? $conf['wrap2.']['splitChar'] : '|'));

return $content;

}

/**

* dataWrap

* Sixth of a set of different wraps which will be applied in a certain order before or after other functions that modify the content

* Can fetch additional content the same way data does (i.e. {field:whatever}) and apply it to the wrap before that is applied to the content

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for dataWrap.

* @return string The processed input value

*/

function stdWrap_dataWrap($content = '', $conf = array()) {

$content = $this->dataWrap($content, $conf['dataWrap']);

return $content;

}

/**

* prepend

* A content object that will be prepended to the current content after most of the wraps have already been applied

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for prepend.

* @return string The processed input value

*/

function stdWrap_prepend($content = '', $conf = array()) {

$content = $this->cObjGetSingle($conf['prepend'], $conf['prepend.'], '/stdWrap/.prepend') . $content;

return $content;

}

/**

* append

* A content object that will be appended to the current content after most of the wraps have already been applied

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for append.

* @return string The processed input value

*/

function stdWrap_append($content = '', $conf = array()) {

$content .= $this->cObjGetSingle($conf['append'], $conf['append.'], '/stdWrap/.append');

return $content;

}

/**

* wrap3

* Seventh of a set of different wraps which will be applied in a certain order before or after other functions that modify the content

* The default split character is | but it can be replaced with other characters by the property splitChar

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for wrap3.

* @return string The processed input value

*/

function stdWrap_wrap3($content = '', $conf = array()) {

$content = $this->wrap($content, $conf['wrap3'], ($conf['wrap3.']['splitChar'] ? $conf['wrap3.']['splitChar'] : '|'));

return $content;

}

/**

* outerWrap

* Eighth of a set of different wraps which will be applied in a certain order before or after other functions that modify the content

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for outerWrap.

* @return string The processed input value

*/

function stdWrap_outerWrap($content = '', $conf = array()) {

$content = $this->wrap($content, $conf['outerWrap']);

return $content;

}

/**

* inserData

* Can fetch additional content the same way data does and replaces any occurence of {field:whatever} with this content

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for insertData.

* @return string The processed input value

*/

function stdWrap_insertData($content = '', $conf = array()) {

$content = $this->insertData($content);

return $content;

}

/**

* offsetWrap

* Creates a so called offset table around the content

* Still here for historical reasons even not used too much nowadays

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for offsetWrap.

* @return string The processed input value

*/

function stdWrap_offsetWrap($content = '', $conf = array()) {

$controlTable = t3lib_div::makeInstance('tslib_tableOffset');

if ($conf['offsetWrap.']['tableParams'] || $conf['offsetWrap.']['tableParams.']) {

$controlTable->tableParams = $this->stdWrap($conf['offsetWrap.']['tableParams'], $conf['offsetWrap.']['tableParams.']);

}

if ($conf['offsetWrap.']['tdParams'] || $conf['offsetWrap.']['tdParams.']) {

$controlTable->tdParams = ' ' . $this->stdWrap($conf['offsetWrap.']['tdParams'], $conf['offsetWrap.']['tdParams.']);

}

$content = $controlTable->start($content, $conf['offsetWrap']);

if ($conf['offsetWrap.']['stdWrap.']) {

$content = $this->stdWrap($content, $conf['offsetWrap.']['stdWrap.']);

}

return $content;

}

/**

* postUserFunc

* Will execute a user function after the content has been modified by any other stdWrap function

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for postUserFunc.

* @return string The processed input value

*/

function stdWrap_postUserFunc($content = '', $conf = array()) {

$content = $this->callUserFunction($conf['postUserFunc'], $conf['postUserFunc.'], $content);

return $content;

}

/**

* postUserFuncInt

* Will execute a user function after the content has been created and each time it is fetched from Cache

* The result of this function itself will not be cached

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for postUserFuncInt.

* @return string The processed input value

*/

function stdWrap_postUserFuncInt($content = '', $conf = array()) {

$substKey = 'INT_SCRIPT.' . $GLOBALS['TSFE']->uniqueHash();

$GLOBALS['TSFE']->config['INTincScript'][$substKey] = array(

'content' => $content, 'postUserFunc' => $conf['postUserFuncInt'], 'conf' => $conf['postUserFuncInt.'], 'type' => 'POSTUSERFUNC', 'cObj' => serialize($this)

);

$content = '<!--' . $substKey . '-->';

return $content;

}

/**

* prefixComment

* Will add HTML comments to the content to make it easier to identify certain content elements within the HTML output later on

*

* @param string Input value undergoing processing in this function.

* @param array stdWrap properties for prefixComment.

* @return string The processed input value

*/

function stdWrap_prefixComment($content = '', $conf = array()) {

if (!$GLOBALS['TSFE']->config['config']['disablePrefixComment']) {

$content = $this->prefixComment($conf['prefixComment'], $conf['prefixComment.'], $content);