var/deb-package/cluster_raw_old/opt/cluster/lib/www/ganglia/class.TemplatePower.inc.php

   1 <?php
   2 /* vim: set expandtab tabstop=4 shiftwidth=4: */
   3 // +----------------------------------------------------------------------+
   4 // | TemplatePower:                                                       |
   5 // | offers you the ability to separate your PHP code and your HTML       |
   6 // +----------------------------------------------------------------------+
   7 // |                                                                      |
   8 // | Copyright (C) 2001,2002  R.P.J. Velzeboer, The Netherlands           |
   9 // |                                                                      |
  10 // | This program is free software; you can redistribute it and/or        |
  11 // | modify it under the terms of the GNU General Public License          |
  12 // | as published by the Free Software Foundation; either version 2       |
  13 // | of the License, or (at your option) any later version.               |
  14 // |                                                                      |
  15 // | This program is distributed in the hope that it will be useful,      |
  16 // | but WITHOUT ANY WARRANTY; without even the implied warranty of       |
  17 // | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        |
  18 // | GNU General Public License for more details.                         |
  19 // |                                                                      |
  20 // | You should have received a copy of the GNU General Public License    |
  21 // | along with this program; if not, write to the Free Software          |
  22 // | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA            |
  23 // | 02111-1307, USA.                                                     |
  24 // |                                                                      |
  25 // | Author: R.P.J. Velzeboer, rovel@codocad.nl   The Netherlands         |
  26 // |                                                                      |
  27 // +----------------------------------------------------------------------+
  28 // | http://templatepower.codocad.com                                     |
  29 // +----------------------------------------------------------------------+
  30 //
  31 // $Id: class.TemplatePower.inc.php 459 2004-12-13 19:01:46Z sacerdoti $
  32
  33 define("T_BYFILE",              0);
  34 define("T_BYVAR",               1);
  35
  36 define("TP_ROOTBLOCK",    '_ROOT');
  37
  38 class TemplatePowerParser
  39 {
  40   var $tpl_base;              //Array( [filename/varcontent], [T_BYFILE/T_BYVAR] )
  41   var $tpl_include;           //Array( [filename/varcontent], [T_BYFILE/T_BYVAR] )
  42   var $tpl_count;
  43
  44   var $parent   = Array();    // $parent[{blockname}] = {parentblockname}
  45   var $defBlock = Array();
  46
  47   var $rootBlockName;
  48   var $ignore_stack;
  49
  50   var $version;
  51
  52    /**
  53     * TemplatePowerParser::TemplatePowerParser()
  54     *
  55     * @param $tpl_file
  56     * @param $type
  57     * @return
  58         *
  59         * @access private
  60     */
  61    function TemplatePowerParser( $tpl_file, $type )
  62    {
  63        $this->version        = '3.0.1';
  64
  65        $this->tpl_base       = Array( $tpl_file, $type );
  66        $this->tpl_count      = 0;
  67            $this->ignore_stack   = Array( false );
  68    }
  69
  70    /**
  71     * TemplatePowerParser::__errorAlert()
  72     *
  73     * @param $message
  74     * @return
  75         *
  76         * @access private
  77     */
  78    function __errorAlert( $message )
  79    {
  80        print( '<br>'. $message .'<br>\r\n');
  81    }
  82
  83    /**
  84     * TemplatePowerParser::__prepare()
  85     *
  86     * @return
  87         *
  88         * @access private
  89     */
  90    function __prepare()
  91    {
  92        $this->defBlock[ TP_ROOTBLOCK ] = Array();
  93        $tplvar = $this->__prepareTemplate( $this->tpl_base[0], $this->tpl_base[1]  );
  94
  95        $initdev["varrow"]  = 0;
  96        $initdev["coderow"] = 0;
  97        $initdev["index"]   = 0;
  98        $initdev["ignore"]  = false;
  99
 100        $this->__parseTemplate( $tplvar, TP_ROOTBLOCK, $initdev );
 101        $this->__cleanUp();
 102    }
 103
 104     /**
 105      * TemplatePowerParser::__cleanUp()
 106      *
 107      * @return
 108          *
 109          * @access private
 110      */
 111     function __cleanUp()
 112     {
 113         for( $i=0; $i <= $this->tpl_count; $i++ )
 114         {
 115             $tplvar = 'tpl_rawContent'. $i;
 116             unset( $this->{$tplvar} );
 117         }
 118     }
 119
 120     /**
 121      * TemplatePowerParser::__prepareTemplate()
 122      *
 123      * @param $tpl_file
 124      * @param $type
 125      * @return
 126          *
 127          * @access private
 128      */
 129     function __prepareTemplate( $tpl_file, $type )
 130     {
 131         $tplvar = 'tpl_rawContent'. $this->tpl_count;
 132
 133         if( $type == T_BYVAR )
 134         {
 135             $this->{$tplvar}["content"] = preg_split('/\n/', $tpl_file, -1, PREG_SPLIT_DELIM_CAPTURE);
 136         }
 137         else
 138         {
 139             $this->{$tplvar}["content"] = @file( $tpl_file ) or
 140                 die( $this->__errorAlert('TemplatePower Error: Couldn\'t open [ '. $tpl_file .' ]!'));
 141         }
 142
 143         $this->{$tplvar}["size"]    = sizeof( $this->{$tplvar}["content"] );
 144
 145         $this->tpl_count++;
 146
 147         return $tplvar;
 148     }
 149
 150     /**
 151      * TemplatePowerParser::__parseTemplate()
 152      *
 153      * @param $tplvar
 154      * @param $blockname
 155      * @param $initdev
 156      * @return
 157          *
 158          * @access private
 159      */
 160     function __parseTemplate( $tplvar, $blockname, $initdev )
 161     {
 162         $coderow = $initdev["coderow"];
 163         $varrow  = $initdev["varrow"];
 164         $index   = $initdev["index"];
 165         $ignore  = $initdev["ignore"];
 166
 167         while( $index < $this->{$tplvar}["size"] )
 168         {
 169             if ( preg_match('/<!--[ ]?(START|END) IGNORE -->/', $this->{$tplvar}["content"][$index], $ignreg) )
 170             {
 171                 if( $ignreg[1] == 'START')
 172                 {
 173                     //$ignore = true;
 174                                         array_push( $this->ignore_stack, true );
 175                 }
 176                 else
 177                 {
 178                     //$ignore = false;
 179                                         array_pop( $this->ignore_stack );
 180                 }
 181             }
 182             else
 183             {
 184                 if( !end( $this->ignore_stack ) )
 185                 {
 186                     if( preg_match('/<!--[ ]?(START|END|INCLUDE|INCLUDESCRIPT|REUSE) BLOCK : (.+)-->/', $this->{$tplvar}["content"][$index], $regs))
 187                     {
 188                        //remove trailing and leading spaces
 189                         $regs[2] = trim( $regs[2] );
 190
 191                         if( $regs[1] == 'INCLUDE')
 192                         {
 193                             $include_defined = true;
 194
 195                            //check if the include file is assigned
 196                             if( isset( $this->tpl_include[ $regs[2] ]) )
 197                             {
 198                                 $tpl_file = $this->tpl_include[ $regs[2] ][0];
 199                                 $type   = $this->tpl_include[ $regs[2] ][1];
 200                             }
 201                             else
 202                             if (file_exists( $regs[2] ))    //check if defined as constant in template
 203                             {
 204                                 $tpl_file = $regs[2];
 205                                 $type     = T_BYFILE;
 206                             }
 207                             else
 208                             {
 209                                 $include_defined = false;
 210                             }
 211
 212                             if( $include_defined )
 213                             {
 214                                //initialize startvalues for recursive call
 215                                 $initdev["varrow"]  = $varrow;
 216                                 $initdev["coderow"] = $coderow;
 217                                 $initdev["index"]   = 0;
 218                                 $initdev["ignore"]  = false;
 219
 220                                 $tplvar2 = $this->__prepareTemplate( $tpl_file, $type );
 221                                 $initdev = $this->__parseTemplate( $tplvar2, $blockname, $initdev );
 222
 223                                 $coderow = $initdev["coderow"];
 224                                 $varrow  = $initdev["varrow"];
 225                             }
 226                         }
 227                         else
 228                         if( $regs[1] == 'INCLUDESCRIPT' )
 229                         {
 230                             $include_defined = true;
 231
 232                            //check if the includescript file is assigned by the assignInclude function
 233                             if( isset( $this->tpl_include[ $regs[2] ]) )
 234                             {
 235                                 $include_file = $this->tpl_include[ $regs[2] ][0];
 236                                                                 $type         = $this->tpl_include[ $regs[2] ][1];
 237                             }
 238                             else
 239                             if (file_exists( $regs[2] ))    //check if defined as constant in template
 240                             {
 241                                 $include_file = $regs[2];
 242                                                                 $type         = T_BYFILE;
 243                             }
 244                             else
 245                             {
 246                                 $include_defined = false;
 247                             }
 248
 249                             if( $include_defined )
 250                             {
 251                                 ob_start();
 252
 253                                                                 if( $type == T_BYFILE )
 254                                                                 {
 255                                     if( !@include_once( $include_file ) )
 256                                     {
 257                                         $this->__errorAlert( 'TemplatePower Error: Couldn\'t include script [ '. $include_file .' ]!' );
 258                                                                                 exit();
 259                                     }
 260                                                                 }
 261                                                                 else
 262                                                                 {
 263                                                                     eval( "?>" . $include_file );
 264                                                                 }
 265
 266                                 $this->defBlock[$blockname]["_C:$coderow"] = ob_get_contents();
 267                                 $coderow++;
 268
 269                                 ob_end_clean();
 270                             }
 271                         }
 272                         else
 273                         if( $regs[1] == 'REUSE' )
 274                         {
 275                            //do match for 'AS'
 276                             if (preg_match('/(.+) AS (.+)/', $regs[2], $reuse_regs))
 277                             {
 278                                 $originalbname = trim( $reuse_regs[1] );
 279                                 $copybname     = trim( $reuse_regs[2] );
 280
 281                                //test if original block exist
 282                                 if (isset( $this->defBlock[ $originalbname ] ))
 283                                 {
 284                                    //copy block
 285                                     $this->defBlock[ $copybname ] = $this->defBlock[ $originalbname ];
 286
 287                                    //tell the parent that he has a child block
 288                                     $this->defBlock[ $blockname ]["_B:". $copybname ] = '';
 289
 290                                    //create index and parent info
 291                                     $this->index[ $copybname ]  = 0;
 292                                     $this->parent[ $copybname ] = $blockname;
 293                                 }
 294                                 else
 295                                 {
 296                                     $this->__errorAlert('TemplatePower Error: Can\'t find block \''. $originalbname .'\' to REUSE as \''. $copybname .'\'');
 297                                 }
 298                             }
 299                             else
 300                             {
 301                                //so it isn't a correct REUSE tag, save as code
 302                                 $this->defBlock[$blockname]["_C:$coderow"] = $this->{$tplvar}["content"][$index];
 303                                 $coderow++;
 304                             }
 305                         }
 306                         else
 307                         {
 308                             if( $regs[2] == $blockname )     //is it the end of a block
 309                             {
 310                                 break;
 311                             }
 312                             else                             //its the start of a block
 313                             {
 314                                //make a child block and tell the parent that he has a child
 315                                 $this->defBlock[ $regs[2] ] = Array();
 316                                 $this->defBlock[ $blockname ]["_B:". $regs[2]] = '';
 317
 318                                //set some vars that we need for the assign functions etc.
 319                                 $this->index[ $regs[2] ]  = 0;
 320                                 $this->parent[ $regs[2] ] = $blockname;
 321
 322                                //prepare for the recursive call
 323                                 $index++;
 324                                 $initdev["varrow"]  = 0;
 325                                 $initdev["coderow"] = 0;
 326                                 $initdev["index"]   = $index;
 327                                 $initdev["ignore"]  = false;
 328
 329                                 $initdev = $this->__parseTemplate( $tplvar, $regs[2], $initdev );
 330
 331                                 $index = $initdev["index"];
 332                             }
 333                         }
 334                     }
 335                     else                                                        //is it code and/or var(s)
 336                     {
 337                        //explode current template line on the curly bracket '{'
 338                         $sstr = explode( '{', $this->{$tplvar}["content"][$index] );
 339
 340                                                 reset( $sstr );
 341
 342                         if (current($sstr) != '')
 343                         {
 344                            //the template didn't start with a '{',
 345                            //so the first element of the array $sstr is just code
 346                             $this->defBlock[$blockname]["_C:$coderow"] = current( $sstr );
 347                             $coderow++;
 348                         }
 349
 350                         while (next($sstr))
 351                         {
 352                            //find the position of the end curly bracket '}'
 353                             $pos = strpos( current($sstr), "}" );
 354
 355                             if ( ($pos !== false) && ($pos > 0) )
 356                             {
 357                               //a curly bracket '}' is found
 358                               //and at least on position 1, to eliminate '{}'
 359
 360                               //note: position 1 taken without '{', because we did explode on '{'
 361
 362                                 $strlength = strlen( current($sstr) );
 363                                 $varname   = substr( current($sstr), 0, $pos );
 364
 365                                 if (strstr( $varname, ' ' ))
 366                                 {
 367                                    //the varname contains one or more spaces
 368                                    //so, it isn't a variable, save as code
 369                                     $this->defBlock[$blockname]["_C:$coderow"] = '{'. current( $sstr );
 370                                     $coderow++;
 371                                 }
 372                                 else
 373                                 {
 374                                    //save the variable
 375                                     $this->defBlock[$blockname]["_V:$varrow" ] = $varname;
 376                                     $varrow++;
 377
 378                                    //is there some code after the varname left?
 379                                     if( ($pos + 1) != $strlength )
 380                                     {
 381                                        //yes, save that code
 382                                         $this->defBlock[$blockname]["_C:$coderow"] = substr( current( $sstr ), ($pos + 1), ($strlength - ($pos + 1)) );
 383                                         $coderow++;
 384                                     }
 385                                 }
 386                             }
 387                             else
 388                             {
 389                                //no end curly bracket '}' found
 390                                //so, the curly bracket is part of the text. Save as code, with the '{'
 391                                 $this->defBlock[$blockname]["_C:$coderow"] = '{'. current( $sstr );
 392                                 $coderow++;
 393                             }
 394                         }
 395                     }
 396                 }
 397                 else
 398                 {
 399                     $this->defBlock[$blockname]["_C:$coderow"] = $this->{$tplvar}["content"][$index];
 400                     $coderow++;
 401                 }
 402             }
 403
 404             $index++;
 405         }
 406
 407         $initdev["varrow"]  = $varrow;
 408         $initdev["coderow"] = $coderow;
 409         $initdev["index"]   = $index;
 410
 411         return $initdev;
 412     }
 413
 414
 415     /**
 416      * TemplatePowerParser::version()
 417      *
 418      * @return
 419          * @access public
 420      */
 421     function version()
 422     {
 423         return $this->version;
 424     }
 425
 426     /**
 427      * TemplatePowerParser::assignInclude()
 428      *
 429      * @param $iblockname
 430      * @param $value
 431      * @param $type
 432          *
 433          * @return
 434          *
 435          * @access public
 436      */
 437     function assignInclude( $iblockname, $value, $type=T_BYFILE )
 438     {
 439         $this->tpl_include["$iblockname"] = Array( $value, $type );
 440     }
 441 }
 442
 443 class TemplatePower extends TemplatePowerParser
 444 {
 445   var $index    = Array();        // $index[{blockname}]  = {indexnumber}
 446   var $content  = Array();
 447
 448   var $currentBlock;
 449   var $showUnAssigned;
 450   var $serialized;
 451   var $globalvars = Array();
 452   var $prepared;
 453
 454     /**
 455      * TemplatePower::TemplatePower()
 456      *
 457      * @param $tpl_file
 458      * @param $type
 459      * @return
 460          *
 461          * @access public
 462      */
 463     function TemplatePower( $tpl_file='', $type= T_BYFILE )
 464     {
 465         TemplatePowerParser::TemplatePowerParser( $tpl_file, $type );
 466
 467         $this->prepared       = false;
 468         $this->showUnAssigned = false;
 469                 $this->serialized     = false;  //added: 26 April 2002
 470     }
 471
 472     /**
 473      * TemplatePower::__deSerializeTPL()
 474      *
 475      * @param $stpl_file
 476      * @param $tplvar
 477      * @return
 478          *
 479          * @access private
 480      */
 481     function __deSerializeTPL( $stpl_file, $type )
 482     {
 483         if( $type == T_BYFILE )
 484         {
 485             $serializedTPL = @file( $stpl_file ) or
 486                 die( $this->__errorAlert('TemplatePower Error: Can\'t open [ '. $stpl_file .' ]!'));
 487         }
 488         else
 489         {
 490             $serializedTPL = $stpl_file;
 491         }
 492
 493         $serializedStuff = unserialize( join ('', $serializedTPL) );
 494
 495         $this->defBlock = $serializedStuff["defBlock"];
 496         $this->index    = $serializedStuff["index"];
 497         $this->parent   = $serializedStuff["parent"];
 498     }
 499
 500     /**
 501      * TemplatePower::__makeContentRoot()
 502      *
 503      * @return
 504          *
 505          * @access private
 506      */
 507     function __makeContentRoot()
 508     {
 509         $this->content[ TP_ROOTBLOCK ."_0"  ][0] = Array( TP_ROOTBLOCK );
 510         $this->currentBlock = &$this->content[ TP_ROOTBLOCK ."_0" ][0];
 511     }
 512
 513     /**
 514      * TemplatePower::__assign()
 515      *
 516      * @param $varname
 517      * @param $value
 518      * @return
 519          *
 520          * @access private
 521      */
 522     function __assign( $varname, $value)
 523     {
 524         if( sizeof( $regs = explode('.', $varname ) ) == 2 )  //this is faster then preg_match
 525         {
 526                 $ind_blockname = $regs[0] .'_'. $this->index[ $regs[0] ];
 527
 528             $lastitem = sizeof( $this->content[ $ind_blockname ] );
 529
 530             $lastitem > 1 ? $lastitem-- : $lastitem = 0;
 531
 532             $block = &$this->content[ $ind_blockname ][ $lastitem ];
 533             $varname = $regs[1];
 534         }
 535         else
 536         {
 537             $block = &$this->currentBlock;
 538         }
 539
 540         $block["_V:$varname"] = $value;
 541
 542     }
 543
 544     /**
 545      * TemplatePower::__assignGlobal()
 546      *
 547      * @param $varname
 548      * @param $value
 549      * @return
 550          *
 551          * @access private
 552      */
 553     function __assignGlobal( $varname, $value )
 554     {
 555         $this->globalvars[ $varname ] = $value;
 556     }
 557
 558
 559     /**
 560      * TemplatePower::__outputContent()
 561      *
 562      * @param $blockname
 563      * @return
 564          *
 565          * @access private
 566      */
 567     function __outputContent( $blockname )
 568     {
 569         $numrows = sizeof( $this->content[ $blockname ] );
 570
 571         for( $i=0; $i < $numrows; $i++)
 572         {
 573             $defblockname = $this->content[ $blockname ][$i][0];
 574
 575             for( reset( $this->defBlock[ $defblockname ]);  $k = key( $this->defBlock[ $defblockname ]);  next( $this->defBlock[ $defblockname ] ) )
 576             {
 577                 if ($k[1] == 'C')
 578                 {
 579                     print( $this->defBlock[ $defblockname ][$k] );
 580                 }
 581                 else
 582                 if ($k[1] == 'V')
 583                 {
 584                     $defValue = $this->defBlock[ $defblockname ][$k];
 585
 586                     if( !isset( $this->content[ $blockname ][$i][ "_V:". $defValue ] ) )
 587                     {
 588                         if( isset( $this->globalvars[ $defValue ] ) )
 589                         {
 590                             $value = $this->globalvars[ $defValue ];
 591                         }
 592                         else
 593                         {
 594                             if( $this->showUnAssigned )
 595                             {
 596                                 //$value = '{'. $this->defBlock[ $defblockname ][$k] .'}';
 597                                 $value = '{'. $defValue .'}';
 598                             }
 599                             else
 600                             {
 601                                 $value = '';
 602                             }
 603                         }
 604                     }
 605                     else
 606                     {
 607                         $value = $this->content[ $blockname ][$i][ "_V:". $defValue ];
 608                     }
 609
 610                     print( $value );
 611
 612                 }
 613                 else
 614                 if ($k[1] == 'B')
 615                 {
 616                     if( isset( $this->content[ $blockname ][$i][$k] ) )
 617                     {
 618                         $this->__outputContent( $this->content[ $blockname ][$i][$k] );
 619                     }
 620                 }
 621             }
 622         }
 623     }
 624
 625     function __printVars()
 626     {
 627         var_dump($this->defBlock);
 628         print("<br>--------------------<br>");
 629         var_dump($this->content);
 630     }
 631
 632
 633   /**********
 634       public members
 635             ***********/
 636
 637     /**
 638      * TemplatePower::serializedBase()
 639      *
 640      * @return
 641          *
 642          * @access public
 643      */
 644     function serializedBase()
 645     {
 646         $this->serialized = true;
 647         $this->__deSerializeTPL( $this->tpl_base[0], $this->tpl_base[1] );
 648     }
 649
 650     /**
 651      * TemplatePower::showUnAssigned()
 652      *
 653      * @param $state
 654      * @return
 655          *
 656          * @access public
 657      */
 658     function showUnAssigned( $state = true )
 659     {
 660         $this->showUnAssigned = $state;
 661     }
 662
 663     /**
 664      * TemplatePower::prepare()
 665      *
 666      * @return
 667          *
 668          * @access public
 669      */
 670     function prepare()
 671     {
 672         if (!$this->serialized)
 673         {
 674             TemplatePowerParser::__prepare();
 675         }
 676
 677         $this->prepared = true;
 678
 679         $this->index[ TP_ROOTBLOCK ]    = 0;
 680         $this->__makeContentRoot();
 681     }
 682
 683     /**
 684      * TemplatePower::newBlock()
 685      *
 686      * @param $blockname
 687      * @return
 688          *
 689          * @access public
 690      */
 691     function newBlock( $blockname )
 692     {
 693         $parent = &$this->content[ $this->parent[$blockname] .'_'. $this->index[$this->parent[$blockname]] ];
 694
 695                 $lastitem = sizeof( $parent );
 696         $lastitem > 1 ? $lastitem-- : $lastitem = 0;
 697
 698                 $ind_blockname = $blockname .'_'. $this->index[ $blockname ];
 699
 700         if ( !isset( $parent[ $lastitem ]["_B:$blockname"] ))
 701         {
 702            //ok, there is no block found in the parentblock with the name of {$blockname}
 703
 704            //so, increase the index counter and create a new {$blockname} block
 705             $this->index[ $blockname ] += 1;
 706
 707             $ind_blockname = $blockname .'_'. $this->index[ $blockname ];
 708
 709             if (!isset( $this->content[ $ind_blockname ] ) )
 710             {
 711                  $this->content[ $ind_blockname ] = Array();
 712             }
 713
 714            //tell the parent where his (possible) children are located
 715             $parent[ $lastitem ]["_B:$blockname"] = $ind_blockname;
 716         }
 717
 718        //now, make a copy of the block defenition
 719         $blocksize = sizeof( $this->content[ $ind_blockname ] );
 720
 721         $this->content[ $ind_blockname ][ $blocksize ] = Array( $blockname );
 722
 723        //link the current block to the block we just created
 724         $this->currentBlock = &$this->content[ $ind_blockname ][ $blocksize ];
 725     }
 726
 727     /**
 728      * TemplatePower::assignGlobal()
 729      *
 730      * @param $varname
 731      * @param $value
 732      * @return
 733          *
 734          * @access public
 735      */
 736     function assignGlobal( $varname, $value )
 737     {
 738         if (is_array( $varname ))
 739         {
 740             foreach($varname as $var => $value)
 741             {
 742                 $this->__assignGlobal( $var, $value );
 743             }
 744         }
 745         else
 746         {
 747             $this->__assignGlobal( $varname, $value );
 748         }
 749     }
 750
 751
 752     /**
 753      * TemplatePower::assign()
 754      *
 755      * @param $varname
 756      * @param $value
 757      * @return
 758          *
 759          * @access public
 760      */
 761     function assign( $varname, $value='' )
 762     {
 763         if (is_array( $varname ))
 764         {
 765             foreach($varname as $var => $value)
 766             {
 767                 $this->__assign( $var, $value );
 768             }
 769         }
 770         else
 771         {
 772             $this->__assign( $varname, $value );
 773         }
 774     }
 775
 776     /**
 777      * TemplatePower::gotoBlock()
 778      *
 779      * @param $blockname
 780      * @return
 781          *
 782          * @access public
 783      */
 784     function gotoBlock( $blockname )
 785     {
 786         if ( isset( $this->defBlock[ $blockname ] ) )
 787         {
 788                     $ind_blockname = $blockname .'_'. $this->index[ $blockname ];
 789
 790            //get lastitem indexnumber
 791             $lastitem = sizeof( $this->content[ $ind_blockname ] );
 792
 793             $lastitem > 1 ? $lastitem-- : $lastitem = 0;
 794
 795            //link the current block
 796             $this->currentBlock = &$this->content[ $ind_blockname ][ $lastitem ];
 797         }
 798     }
 799
 800     /**
 801      * TemplatePower::getVarValue()
 802      *
 803      * @param $varname
 804      * @return
 805          *
 806          * @access public
 807      */
 808     function getVarValue( $varname )
 809     {
 810         if( sizeof( $regs = explode('.', $varname ) ) == 2 )  //this is faster then preg_match
 811         {
 812                     $ind_blockname = $regs[0] .'_'. $this->index[ $regs[0] ];
 813
 814             $lastitem = sizeof( $this->content[ $ind_blockname ] );
 815
 816             $lastitem > 1 ? $lastitem-- : $lastitem = 0;
 817
 818             $block = &$this->content[ $ind_blockname ][ $lastitem ];
 819             $varname = $regs[1];
 820         }
 821         else
 822         {
 823             $block = &$this->currentBlock;
 824         }
 825
 826         return $block["_V:$varname"];
 827     }
 828
 829     /**
 830      * TemplatePower::printToScreen()
 831      *
 832      * @return
 833          *
 834          * @access public
 835      */
 836     function printToScreen()
 837     {
 838         if ($this->prepared)
 839         {
 840             $this->__outputContent( TP_ROOTBLOCK .'_0' );
 841         }
 842         else
 843         {
 844             $this->__errorAlert('TemplatePower Error: Template isn\'t prepared!');
 845         }
 846     }
 847
 848     /**
 849      * TemplatePower::getOutputContent()
 850      *
 851      * @return
 852          *
 853          * @access public
 854      */
 855     function getOutputContent()
 856     {
 857         ob_start();
 858
 859         $this->printToScreen();
 860
 861         $content = ob_get_contents();
 862
 863         ob_end_clean();
 864
 865         return $content;
 866     }
 867 }
 868 ?>