Spaces:
Sleeping
Sleeping
| /** | |
| * class.templatePower.php | |
| * | |
| * @package gulliver.system | |
| * | |
| * ProcessMaker Open Source Edition | |
| * Copyright (C) 2004 - 2011 Colosa Inc. | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Affero General Public License as | |
| * published by the Free Software Foundation, either version 3 of the | |
| * License, or (at your option) any later version. | |
| * | |
| * This program 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 Affero General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Affero General Public License | |
| * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| * | |
| * For more information, contact Colosa Inc, 2566 Le Jeune Rd., | |
| * Coral Gables, FL, 33134, USA, or email info@colosa.com. | |
| * | |
| */ | |
| /* vim: set expandtab tabstop=4 shiftwidth=4: */ | |
| // +----------------------------------------------------------------------+ | |
| // | TemplatePower: | | |
| // | offers you the ability to separate your PHP code and your HTML | | |
| // +----------------------------------------------------------------------+ | |
| // | | | |
| // | Copyright (C) 2001,2002 R.P.J. Velzeboer, The Netherlands | | |
| // | | | |
| // | This program 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. | | |
| // | | | |
| // | This program 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. | | |
| // | | | |
| // | You should have received a copy of the GNU General Public License | | |
| // | along with this program; if not, write to the Free Software | | |
| // | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA | | |
| // | 02111-1307, USA. | | |
| // | | | |
| // | Author: R.P.J. Velzeboer, rovel@codocad.nl The Netherlands | | |
| // | | | |
| // +----------------------------------------------------------------------+ | |
| // | http://templatepower.codocad.com | | |
| // +----------------------------------------------------------------------+ | |
| // | |
| // $Id: Version 3.0.2$ | |
| /** | |
| * | |
| * @package gulliver.system | |
| * | |
| */ | |
| define( "T_BYFILE", 0 ); | |
| define( "T_BYVAR", 1 ); | |
| define( "TP_ROOTBLOCK", '_ROOT' ); | |
| /** | |
| * class TemplatePowerParser | |
| * | |
| * @package gulliver.system | |
| * | |
| */ | |
| class TemplatePowerParser | |
| { | |
| public $tpl_base; | |
| //Array( [filename/varcontent], [T_BYFILE/T_BYVAR] ) | |
| public $tpl_include; | |
| //Array( [filename/varcontent], [T_BYFILE/T_BYVAR] ) | |
| public $tpl_count; | |
| public $parent = Array (); | |
| // $parent[{blockname}] = {parentblockname} | |
| public $defBlock = Array (); | |
| public $rootBlockName; | |
| public $ignore_stack; | |
| public $version; | |
| public $unhtmlentities = 0; | |
| /** | |
| * TemplatePowerParser::TemplatePowerParser() | |
| * | |
| * @param string $tpl_file | |
| * @param string $type | |
| * @access private | |
| */ | |
| public function TemplatePowerParser ($tpl_file, $type) | |
| { | |
| $this->version = '3.0.2'; | |
| $this->tpl_base = Array ($tpl_file,$type); | |
| $this->tpl_count = 0; | |
| $this->ignore_stack = Array (false); | |
| } | |
| /** | |
| * TemplatePowerParser::__errorAlert() | |
| * | |
| * @param string $message | |
| * | |
| * @access private | |
| */ | |
| public function __errorAlert ($message) | |
| { | |
| print ('<br>' . $message . '<br>' . "\r\n") ; | |
| } | |
| /** | |
| * TemplatePowerParser::__prepare() | |
| * | |
| * @access private | |
| * @return void | |
| */ | |
| public function __prepare () | |
| { | |
| $this->defBlock[TP_ROOTBLOCK] = Array (); | |
| $tplvar = $this->__prepareTemplate( $this->tpl_base[0], $this->tpl_base[1] ); | |
| $initdev["varrow"] = 0; | |
| $initdev["coderow"] = 0; | |
| $initdev["index"] = 0; | |
| $initdev["ignore"] = false; | |
| $this->__parseTemplate( $tplvar, TP_ROOTBLOCK, $initdev ); | |
| $this->__cleanUp(); | |
| } | |
| /** | |
| * TemplatePowerParser::__cleanUp() | |
| * | |
| * @return void | |
| * | |
| * @access private | |
| */ | |
| public function __cleanUp () | |
| { | |
| for ($i = 0; $i <= $this->tpl_count; $i ++) { | |
| $tplvar = 'tpl_rawContent' . $i; | |
| unset( $this->{$tplvar} ); | |
| } | |
| } | |
| /** | |
| * TemplatePowerParser::__prepareTemplate() | |
| * | |
| * @param string $tpl_file | |
| * @param string $type | |
| * @access private | |
| */ | |
| public function __prepareTemplate ($tpl_file, $type) | |
| { | |
| $tplvar = 'tpl_rawContent' . $this->tpl_count; | |
| if ($type == T_BYVAR) { | |
| $this->{$tplvar}["content"] = preg_split( "/\n/", $tpl_file, - 1, PREG_SPLIT_DELIM_CAPTURE ); | |
| } else { | |
| //Trigger the error in the local scope of the function | |
| //trigger_error ("Some error", E_USER_WARNING); | |
| $this->{$tplvar}["content"] = @file( $tpl_file ) or die( $this->__errorAlert( 'TemplatePower Error: Couldn\'t open [ ' . $tpl_file . ' ]!' ) ); | |
| } | |
| $this->{$tplvar}["size"] = sizeof( $this->{$tplvar}["content"] ); | |
| $this->tpl_count ++; | |
| return $tplvar; | |
| } | |
| /** | |
| * TemplatePowerParser::__parseTemplate() | |
| * | |
| * @param string $tplvar | |
| * @param string $blockname | |
| * @param string $initdev | |
| * @access private | |
| */ | |
| public function __parseTemplate ($tplvar, $blockname, $initdev) | |
| { | |
| $coderow = $initdev["coderow"]; | |
| $varrow = $initdev["varrow"]; | |
| $index = $initdev["index"]; | |
| $ignore = $initdev["ignore"]; | |
| while ($index < $this->{$tplvar}["size"]) { | |
| if (preg_match( '/<!--[ ]?(START|END) IGNORE -->/', $this->{$tplvar}["content"][$index], $ignreg )) { | |
| if ($ignreg[1] == 'START') { | |
| //$ignore = true; | |
| array_push( $this->ignore_stack, true ); | |
| } else { | |
| //$ignore = false; | |
| array_pop( $this->ignore_stack ); | |
| } | |
| } else { | |
| if (! end( $this->ignore_stack )) { | |
| if (preg_match( '/<!--[ ]?(START|END|INCLUDE|INCLUDESCRIPT|REUSE) BLOCK : (.+)-->/', $this->{$tplvar}["content"][$index], $regs )) { | |
| //remove trailing and leading spaces | |
| $regs[2] = trim( $regs[2] ); | |
| if ($regs[1] == 'INCLUDE') { | |
| $include_defined = true; | |
| //check if the include file is assigned | |
| if (isset( $this->tpl_include[$regs[2]] )) { | |
| $tpl_file = $this->tpl_include[$regs[2]][0]; | |
| $type = $this->tpl_include[$regs[2]][1]; | |
| } elseif (file_exists( $regs[2] )) { | |
| //check if defined as constant in template | |
| $tpl_file = $regs[2]; | |
| $type = T_BYFILE; | |
| } else { | |
| $include_defined = false; | |
| } | |
| if ($include_defined) { | |
| //initialize startvalues for recursive call | |
| $initdev["varrow"] = $varrow; | |
| $initdev["coderow"] = $coderow; | |
| $initdev["index"] = 0; | |
| $initdev["ignore"] = false; | |
| $tplvar2 = $this->__prepareTemplate( $tpl_file, $type ); | |
| $initdev = $this->__parseTemplate( $tplvar2, $blockname, $initdev ); | |
| $coderow = $initdev["coderow"]; | |
| $varrow = $initdev["varrow"]; | |
| } | |
| } elseif ($regs[1] == 'INCLUDESCRIPT') { | |
| $include_defined = true; | |
| //check if the includescript file is assigned by the assignInclude function | |
| if (isset( $this->tpl_include[$regs[2]] )) { | |
| $include_file = $this->tpl_include[$regs[2]][0]; | |
| $type = $this->tpl_include[$regs[2]][1]; | |
| } elseif (file_exists( $regs[2] )) { | |
| //check if defined as constant in template | |
| $include_file = $regs[2]; | |
| $type = T_BYFILE; | |
| } else { | |
| $include_defined = false; | |
| } | |
| if ($include_defined) { | |
| ob_start(); | |
| if ($type == T_BYFILE) { | |
| if (! @include_once ($include_file)) { | |
| $this->__errorAlert( 'TemplatePower Error: Couldn\'t include script [ ' . $include_file . ' ]!' ); | |
| exit(); | |
| } | |
| } else { | |
| eval( "?>" . $include_file ); | |
| } | |
| $this->defBlock[$blockname]["_C:$coderow"] = ob_get_contents(); | |
| $coderow ++; | |
| ob_end_clean(); | |
| } | |
| } elseif ($regs[1] == 'REUSE') { | |
| //do match for 'AS' | |
| if (preg_match( '/(.+) AS (.+)/', $regs[2], $reuse_regs )) { | |
| $originalbname = trim( $reuse_regs[1] ); | |
| $copybname = trim( $reuse_regs[2] ); | |
| //test if original block exist | |
| if (isset( $this->defBlock[$originalbname] )) { | |
| //copy block | |
| $this->defBlock[$copybname] = $this->defBlock[$originalbname]; | |
| //tell the parent that he has a child block | |
| $this->defBlock[$blockname]["_B:" . $copybname] = ''; | |
| //create index and parent info | |
| $this->index[$copybname] = 0; | |
| $this->parent[$copybname] = $blockname; | |
| } else { | |
| $this->__errorAlert( 'TemplatePower Error: Can\'t find block \'' . $originalbname . '\' to REUSE as \'' . $copybname . '\'' ); | |
| } | |
| } else { | |
| //so it isn't a correct REUSE tag, save as code | |
| $this->defBlock[$blockname]["_C:$coderow"] = $this->{$tplvar}["content"][$index]; | |
| $coderow ++; | |
| } | |
| } else { | |
| if ($regs[2] == $blockname) { | |
| //is it the end of a block | |
| break; | |
| } else { | |
| //its the start of a block | |
| //make a child block and tell the parent that he has a child | |
| $this->defBlock[$regs[2]] = Array (); | |
| $this->defBlock[$blockname]["_B:" . $regs[2]] = ''; | |
| //set some vars that we need for the assign functions etc. | |
| $this->index[$regs[2]] = 0; | |
| $this->parent[$regs[2]] = $blockname; | |
| //prepare for the recursive call | |
| $index ++; | |
| $initdev["varrow"] = 0; | |
| $initdev["coderow"] = 0; | |
| $initdev["index"] = $index; | |
| $initdev["ignore"] = false; | |
| $initdev = $this->__parseTemplate( $tplvar, $regs[2], $initdev ); | |
| $index = $initdev["index"]; | |
| } | |
| } | |
| } else { | |
| //is it code and/or var(s) | |
| //explode current template line on the curly bracket '{' | |
| $sstr = explode( '{', $this->{$tplvar}["content"][$index] ); | |
| reset( $sstr ); | |
| if (current( $sstr ) != '') { | |
| //the template didn't start with a '{', | |
| //so the first element of the array $sstr is just code | |
| $this->defBlock[$blockname]["_C:$coderow"] = current( $sstr ); | |
| $coderow ++; | |
| } | |
| while (next( $sstr )) { | |
| //find the position of the end curly bracket '}' | |
| $pos = strpos( current( $sstr ), "}" ); | |
| if (($pos !== false) && ($pos > 0)) { | |
| //a curly bracket '}' is found | |
| //and at least on position 1, to eliminate '{}' | |
| //note: position 1 taken without '{', because we did explode on '{' | |
| $strlength = strlen( current( $sstr ) ); | |
| $varname = substr( current( $sstr ), 0, $pos ); | |
| if (strstr( $varname, ' ' )) { | |
| //the varname contains one or more spaces | |
| //so, it isn't a variable, save as code | |
| $this->defBlock[$blockname]["_C:$coderow"] = '{' . current( $sstr ); | |
| $coderow ++; | |
| } else { | |
| //save the variable | |
| $this->defBlock[$blockname]["_V:$varrow"] = $varname; | |
| $varrow ++; | |
| //is there some code after the varname left? | |
| if (($pos + 1) != $strlength) { | |
| //yes, save that code | |
| $this->defBlock[$blockname]["_C:$coderow"] = substr( current( $sstr ), ($pos + 1), ($strlength - ($pos + 1)) ); | |
| $coderow ++; | |
| } | |
| } | |
| } else { | |
| //no end curly bracket '}' found | |
| //so, the curly bracket is part of the text. Save as code, with the '{' | |
| $this->defBlock[$blockname]["_C:$coderow"] = '{' . current( $sstr ); | |
| $coderow ++; | |
| } | |
| } | |
| } | |
| } else { | |
| $this->defBlock[$blockname]["_C:$coderow"] = $this->{$tplvar}["content"][$index]; | |
| $coderow ++; | |
| } | |
| } | |
| $index ++; | |
| } | |
| $initdev["varrow"] = $varrow; | |
| $initdev["coderow"] = $coderow; | |
| $initdev["index"] = $index; | |
| return $initdev; | |
| } | |
| /** | |
| * TemplatePowerParser::version() | |
| * | |
| * @return void | |
| * @access public | |
| */ | |
| public function version () | |
| { | |
| return $this->version; | |
| } | |
| /** | |
| * TemplatePowerParser::assignInclude() | |
| * | |
| * @param string $iblockname | |
| * @param string $value | |
| * @param string $type | |
| * @return void | |
| * @access public | |
| */ | |
| public function assignInclude ($iblockname, $value, $type = T_BYFILE) | |
| { | |
| $this->tpl_include["$iblockname"] = Array ($value,$type); | |
| } | |
| } | |
| /** | |
| * class TemplatePower | |
| * | |
| * @package gulliver.system | |
| */ | |
| class TemplatePower extends TemplatePowerParser | |
| { | |
| public $index = Array (); | |
| // $index[{blockname}] = {indexnumber} | |
| public $content = Array (); | |
| public $currentBlock; | |
| public $showUnAssigned; | |
| public $serialized; | |
| public $globalvars = Array (); | |
| public $prepared; | |
| /** | |
| * TemplatePower::TemplatePower() | |
| * | |
| * @param string $tpl_file | |
| * @param string $type | |
| * @return void | |
| * @access public | |
| */ | |
| public function TemplatePower ($tpl_file = '', $type = T_BYFILE) | |
| { | |
| TemplatePowerParser::TemplatePowerParser( $tpl_file, $type ); | |
| $this->prepared = false; | |
| $this->showUnAssigned = false; | |
| $this->serialized = false; | |
| //added: 26 April 2002 | |
| } | |
| /** | |
| * TemplatePower::__deSerializeTPL() | |
| * | |
| * @param string $stpl_file | |
| * @param string $tplvar | |
| * @return void | |
| * @access private | |
| */ | |
| public function __deSerializeTPL ($stpl_file, $type) | |
| { | |
| if ($type == T_BYFILE) { | |
| $serializedTPL = @file( $stpl_file ) or die( $this->__errorAlert( 'TemplatePower Error: Can\'t open [ ' . $stpl_file . ' ]!' ) ); | |
| } else { | |
| $serializedTPL = $stpl_file; | |
| } | |
| $serializedStuff = unserialize( join( '', $serializedTPL ) ); | |
| $this->defBlock = $serializedStuff["defBlock"]; | |
| $this->index = $serializedStuff["index"]; | |
| $this->parent = $serializedStuff["parent"]; | |
| } | |
| /** | |
| * TemplatePower::__makeContentRoot() | |
| * | |
| * @return void | |
| * @access private | |
| */ | |
| public function __makeContentRoot () | |
| { | |
| $this->content[TP_ROOTBLOCK . "_0"][0] = Array (TP_ROOTBLOCK); | |
| $this->currentBlock = &$this->content[TP_ROOTBLOCK . "_0"][0]; | |
| } | |
| /** | |
| * TemplatePower::__assign() | |
| * | |
| * @param string $varname | |
| * @param string $value | |
| * @return void | |
| * | |
| * @access private | |
| */ | |
| public function __assign ($varname, $value) | |
| { | |
| if (sizeof( $regs = explode( '.', $varname ) ) == 2) { | |
| //this is faster then preg_match | |
| $ind_blockname = $regs[0] . '_' . $this->index[$regs[0]]; | |
| $lastitem = sizeof( $this->content[$ind_blockname] ); | |
| $lastitem > 1 ? $lastitem -- : $lastitem = 0; | |
| $block = &$this->content[$ind_blockname][$lastitem]; | |
| $varname = $regs[1]; | |
| } else { | |
| $block = &$this->currentBlock; | |
| } | |
| $block["_V:$varname"] = $value; | |
| } | |
| /** | |
| * TemplatePower::__assignGlobal() | |
| * | |
| * @param string $varname | |
| * @param string $value | |
| * @return void | |
| * @access private | |
| */ | |
| public function __assignGlobal ($varname, $value) | |
| { | |
| $this->globalvars[$varname] = $value; | |
| } | |
| /** | |
| * TemplatePower::__outputContent() | |
| * | |
| * @param string $blockname | |
| * @return void | |
| * @access private | |
| */ | |
| public function __outputContent ($blockname) | |
| { | |
| $numrows = sizeof( $this->content[$blockname] ); | |
| for ($i = 0; $i < $numrows; $i ++) { | |
| $defblockname = $this->content[$blockname][$i][0]; | |
| for (reset( $this->defBlock[$defblockname] ); $k = key( $this->defBlock[$defblockname] ); next( $this->defBlock[$defblockname] )) { | |
| if ($k[1] == 'C') { | |
| print ($this->defBlock[$defblockname][$k]) ; | |
| } elseif ($k[1] == 'V') { | |
| $defValue = $this->defBlock[$defblockname][$k]; | |
| if (! isset( $this->content[$blockname][$i]["_V:" . $defValue] )) { | |
| if (isset( $this->globalvars[$defValue] )) { | |
| $value = $this->globalvars[$defValue]; | |
| } else { | |
| //Verify if $defValue is like | |
| // "xmlfile:ID_LABEL" | |
| //if it is load an xml label. | |
| //if not continues with non assigned value. | |
| if (preg_match( "/(.+):(.+)/", $defValue, $xmlreg )) { | |
| $value = G::LoadTranslation(/*$xmlreg[1],*/$xmlreg[2] ); | |
| } else { | |
| if ($this->showUnAssigned) { | |
| //$value = '{'. $this->defBlock[ $defblockname ][$k] .'}'; | |
| $value = '{' . $defValue . '}'; | |
| } else { | |
| $value = ''; | |
| } | |
| } | |
| } | |
| } else { | |
| $value = $this->content[$blockname][$i]["_V:" . $defValue]; | |
| } | |
| if ($this->unhtmlentities) | |
| $value = G::unhtmlentities( $value ); | |
| print ($value) ; | |
| } elseif ($k[1] == 'B') { | |
| if (isset( $this->content[$blockname][$i][$k] )) { | |
| $this->__outputContent( $this->content[$blockname][$i][$k] ); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * function __printVars | |
| * | |
| * @return void | |
| * @access public | |
| */ | |
| public function __printVars () | |
| { | |
| var_dump( $this->defBlock ); | |
| print ("<br>--------------------<br>") ; | |
| var_dump( $this->content ); | |
| } | |
| /** | |
| * ******** | |
| * public members | |
| * ********* | |
| */ | |
| /** | |
| * TemplatePower::serializedBase() | |
| * | |
| * @return void | |
| * | |
| * @access public | |
| */ | |
| public function serializedBase () | |
| { | |
| $this->serialized = true; | |
| $this->__deSerializeTPL( $this->tpl_base[0], $this->tpl_base[1] ); | |
| } | |
| /** | |
| * TemplatePower::showUnAssigned() | |
| * | |
| * @param $state | |
| * @return void | |
| * @access public | |
| */ | |
| public function showUnAssigned ($state = true) | |
| { | |
| $this->showUnAssigned = $state; | |
| } | |
| /** | |
| * TemplatePower::prepare() | |
| * | |
| * @return void | |
| * @access public | |
| */ | |
| public function prepare () | |
| { | |
| if (! $this->serialized) { | |
| TemplatePowerParser::__prepare(); | |
| } | |
| $this->prepared = true; | |
| $this->index[TP_ROOTBLOCK] = 0; | |
| $this->__makeContentRoot(); | |
| } | |
| /** | |
| * TemplatePower::newBlock() | |
| * | |
| * @param string $blockname | |
| * @return void | |
| * @access public | |
| */ | |
| public function newBlock ($blockname) | |
| { | |
| $parent = &$this->content[$this->parent[$blockname] . '_' . $this->index[$this->parent[$blockname]]]; | |
| $lastitem = sizeof( $parent ); | |
| $lastitem > 1 ? $lastitem -- : $lastitem = 0; | |
| $ind_blockname = $blockname . '_' . $this->index[$blockname]; | |
| if (! isset( $parent[$lastitem]["_B:$blockname"] )) { | |
| //ok, there is no block found in the parentblock with the name of {$blockname} | |
| //so, increase the index counter and create a new {$blockname} block | |
| $this->index[$blockname] += 1; | |
| $ind_blockname = $blockname . '_' . $this->index[$blockname]; | |
| if (! isset( $this->content[$ind_blockname] )) { | |
| $this->content[$ind_blockname] = Array (); | |
| } | |
| //tell the parent where his (possible) children are located | |
| $parent[$lastitem]["_B:$blockname"] = $ind_blockname; | |
| } | |
| //now, make a copy of the block defenition | |
| $blocksize = sizeof( $this->content[$ind_blockname] ); | |
| $this->content[$ind_blockname][$blocksize] = Array ($blockname | |
| ); | |
| //link the current block to the block we just created | |
| $this->currentBlock = &$this->content[$ind_blockname][$blocksize]; | |
| } | |
| /** | |
| * TemplatePower::assignGlobal() | |
| * | |
| * @param string $varname | |
| * @param string $value | |
| * @return void | |
| * | |
| * @access public | |
| */ | |
| public function assignGlobal ($varname, $value = '') | |
| { | |
| if (is_array( $varname )) { | |
| foreach ($varname as $var => $value) { | |
| $this->__assignGlobal( $var, $value ); | |
| } | |
| } else { | |
| $this->__assignGlobal( $varname, $value ); | |
| } | |
| } | |
| /** | |
| * TemplatePower::assign() | |
| * | |
| * @param string $varname | |
| * @param string $value | |
| * @return void | |
| * @access public | |
| */ | |
| public function assign ($varname, $value = '') | |
| { | |
| if (is_array( $varname )) { | |
| foreach ($varname as $var => $value) { | |
| $this->__assign( $var, $value ); | |
| } | |
| } else { | |
| $this->__assign( $varname, $value ); | |
| } | |
| } | |
| /** | |
| * TemplatePower::gotoBlock() | |
| * | |
| * @return void | |
| * @param string $blockname | |
| * @access public | |
| */ | |
| public function gotoBlock ($blockname) | |
| { | |
| if (isset( $this->defBlock[$blockname] )) { | |
| $ind_blockname = $blockname . '_' . $this->index[$blockname]; | |
| //get lastitem indexnumber | |
| $lastitem = sizeof( $this->content[$ind_blockname] ); | |
| $lastitem > 1 ? $lastitem -- : $lastitem = 0; | |
| //link the current block | |
| $this->currentBlock = &$this->content[$ind_blockname][$lastitem]; | |
| } | |
| } | |
| /** | |
| * TemplatePower::getVarValue() | |
| * | |
| * @param $varname | |
| * @param string $varname | |
| * @access public | |
| */ | |
| public function getVarValue ($varname) | |
| { | |
| if (sizeof( $regs = explode( '.', $varname ) ) == 2) { | |
| //this is faster then preg_match{ | |
| $ind_blockname = $regs[0] . '_' . $this->index[$regs[0]]; | |
| $lastitem = sizeof( $this->content[$ind_blockname] ); | |
| $lastitem > 1 ? $lastitem -- : $lastitem = 0; | |
| $block = &$this->content[$ind_blockname][$lastitem]; | |
| $varname = $regs[1]; | |
| } else { | |
| $block = &$this->currentBlock; | |
| } | |
| return $block["_V:$varname"]; | |
| } | |
| /** | |
| * TemplatePower::printToScreen() | |
| * | |
| * @return void | |
| * @access public | |
| */ | |
| public function printToScreen () | |
| { | |
| if ($this->prepared) { | |
| $this->__outputContent( TP_ROOTBLOCK . '_0' ); | |
| } else { | |
| $this->__errorAlert( 'TemplatePower Error: Template isn\'t prepared!' ); | |
| } | |
| } | |
| /** | |
| * TemplatePower::getOutputContent() | |
| * | |
| * @return void | |
| * @access public | |
| */ | |
| public function getOutputContent () | |
| { | |
| ob_start(); | |
| $this->printToScreen(); | |
| $content = ob_get_contents(); | |
| ob_end_clean(); | |
| return $content; | |
| } | |
| } | |