Source for file jTpl.class.php

Documentation is available at jTpl.class.php

  1. <?php
  2. /**
  3. @package     jelix
  4. @subpackage  jtpl
  5. @author      Laurent Jouanneau
  6. @contributor Dominique Papin
  7. @copyright   2005-2008 Laurent Jouanneau, 2007 Dominique Papin
  8. @link        http://www.jelix.org
  9. @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
  10. */
  11.  
  12. /**
  13.  * template engine
  14.  * @package     jelix
  15.  * @subpackage  jtpl
  16.  */
  17. class jTpl {
  18.  
  19.     /**
  20.      * all assigned template variables.
  21.      * It have a public access only for plugins. So you musn't use directly this property
  22.      * except from tpl plugins.
  23.      * See methods of jTpl to manage template variables
  24.      * @var array 
  25.      */
  26.     public $_vars = array ();
  27.  
  28.     /**
  29.      * temporary template variables for plugins.
  30.      * It have a public access only for plugins. So you musn't use directly this property
  31.      * except from tpl plugins.
  32.      * @var array 
  33.      */
  34.     public $_privateVars = array ();
  35.  
  36.     /**
  37.      * internal use
  38.      * It have a public access only for plugins. So you musn't use directly this property
  39.      * except from tpl plugins.
  40.      * @var array 
  41.      */
  42.     public $_meta = array();
  43.  
  44.     public function __construct(){
  45.         global $gJConfig;
  46.         $this->_vars['j_basepath'$gJConfig->urlengine['basePath'];
  47.         $this->_vars['j_jelixwww'$gJConfig->urlengine['jelixWWWPath'];
  48.         $this->_vars['j_themepath'$gJConfig->urlengine['basePath'].'themes/'.$gJConfig->theme.'/';
  49.         $this->_vars['j_enableOldActionSelector'$gJConfig->enableOldActionSelector;
  50.         $this->_vars['j_datenow'date('Y-m-d');
  51.         $this->_vars['j_timenow'date('H:i:s');
  52.     }
  53.  
  54.     /**
  55.      * assign a value in a template variable
  56.      * @param string|array$name the variable name, or an associative array 'name'=>'value'
  57.      * @param mixed  $value the value (or null if $name is an array)
  58.      */
  59.     public function assign ($name$value null){
  60.         if(is_array($name)){
  61.             $this->_vars = array_merge($this->_vars$name);
  62.         }else{
  63.             $this->_vars[$name$value;
  64.         }
  65.     }
  66.  
  67.     /**
  68.      * assign a value by reference in a template variable
  69.      * @param string $name the variable name
  70.      * @param mixed  $value the value
  71.      * @since jelix 1.1
  72.      */
  73.     public function assignByRef ($name$value){
  74.         $this->_vars[$name&$value;
  75.     }
  76.  
  77.     /**
  78.      * concat a value in with a value of an existing template variable
  79.      * @param string|array$name the variable name, or an associative array 'name'=>'value'
  80.      * @param mixed  $value the value (or null if $name is an array)
  81.      */
  82.     public function append ($name$value null){
  83.         if(is_array($name)){
  84.            foreach ($name as $key => $val{
  85.                if(isset($this->_vars[$key]))
  86.                   $this->_vars[$key.= $val;
  87.                else
  88.                   $this->_vars[$key$val;
  89.            }
  90.         }else{
  91.             if(isset($this->_vars[$name]))
  92.                $this->_vars[$name.= $value;
  93.             else
  94.                $this->_vars[$name$value;
  95.         }
  96.     }
  97.  
  98.     /**
  99.      * assign a value in a template variable, only if the template variable doesn't exist
  100.      * @param string|array$name the variable name, or an associative array 'name'=>'value'
  101.      * @param mixed  $value the value (or null if $name is an array)
  102.      */
  103.     public function assignIfNone ($name$value null){
  104.         if(is_array($name)){
  105.            foreach ($name as $key => $val{
  106.                if(!isset($this->_vars[$key]))
  107.                   $this->_vars[$key$val;
  108.            }
  109.         }else{
  110.             if(!isset($this->_vars[$name]))
  111.                $this->_vars[$name$value;
  112.         }
  113.     }
  114.  
  115.     /**
  116.      * assign a zone content to a template variable
  117.      * @param string $name the variable name
  118.      * @param string $zoneName  a zone selector
  119.      * @param array  $params  parameters for the zone
  120.      * @see jZone
  121.      */
  122.     function assignZone($name$zoneName$params=array()){
  123.         $this->_vars[$namejZone::get ($zoneName$params);
  124.     }
  125.  
  126.     /**
  127.      * append a zone content to a template variable
  128.      * @param string $name the variable name
  129.      * @param string $zoneName  a zone selector
  130.      * @param array  $params  parameters for the zone
  131.      * @see jZone
  132.      * @since 1.0
  133.      */
  134.     function appendZone($name$zoneName$params=array()){
  135.         if(isset($this->_vars[$name]))
  136.             $this->_vars[$name.= jZone::get ($zoneName$params);
  137.         else
  138.             $this->_vars[$namejZone::get ($zoneName$params);
  139.     }
  140.  
  141.     /**
  142.      * assign a zone content to a template variable only if this variable doesn't exist
  143.      * @param string $name the variable name
  144.      * @param string $zoneName  a zone selector
  145.      * @param array  $params  parameters for the zone
  146.      * @see jZone
  147.      */
  148.     function assignZoneIfNone($name$zoneName$params=array()){
  149.         if(!isset($this->_vars[$name]))
  150.             $this->_vars[$namejZone::get ($zoneName$params);
  151.     }
  152.  
  153.     /**
  154.      * says if a template variable exists
  155.      * @param string $name the variable template name
  156.      * @return boolean true if the variable exists
  157.      */
  158.     public function isAssigned ($name){
  159.         return isset ($this->_vars[$name]);
  160.     }
  161.  
  162.     /**
  163.      * return the value of a template variable
  164.      * @param string $name the variable template name
  165.      * @return mixed the value (or null if it isn't exist)
  166.      */
  167.     public function get ($name){
  168.         if (isset ($this->_vars[$name])){
  169.             return $this->_vars[$name];
  170.         }else{
  171.             $return null;
  172.             return $return;
  173.         }
  174.     }
  175.  
  176.     /**
  177.      * Return all template variables
  178.      * @return array 
  179.      */
  180.     public function getTemplateVars (){
  181.         return $this->_vars;
  182.     }
  183.  
  184.     /**
  185.      * process all meta instruction of a template
  186.      * @param string $tpl template selector
  187.      * @param string $outputtype the type of output (html, text etc..)
  188.      * @param boolean $trusted  says if the template file is trusted or not
  189.      */
  190.     public function meta($tpl$outputtype=''$trusted true){
  191.         $this->getTemplate($tpl,'template_meta_'$outputtype$trusted);
  192.         return $this->_meta;
  193.     }
  194.  
  195.     /**
  196.      * display the generated content from the given template
  197.      * @param string $tpl template selector
  198.      * @param string $outputtype the type of output (html, text etc..)
  199.      * @param boolean $trusted  says if the template file is trusted or not
  200.      */
  201.     public function display ($tpl$outputtype=''$trusted true){
  202.         $this->getTemplate($tpl,'template_'$outputtype$trusted);
  203.     }
  204.  
  205.     /**
  206.      * contains the name of the template file
  207.      * It have a public access only for plugins. So you musn't use directly this property
  208.      * except from tpl plugins.
  209.      * @var string 
  210.      * @since 1.1
  211.      */
  212.     public $_templateName;
  213.  
  214.     /**
  215.      * include the compiled template file and call one of the generated function
  216.      * @param string $tpl template selector
  217.      * @param string $fctname the internal function name (meta or content)
  218.      * @param string $outputtype the type of output (html, text etc..)
  219.      * @param boolean $trusted  says if the template file is trusted or not
  220.      */
  221.     protected function getTemplate($tpl,$fctname$outputtype=''$trusted true){
  222.         $sel new jSelectorTpl($tpl,$outputtype,$trusted);
  223.         $sel->userModifiers $this->userModifiers;
  224.         $sel->userFunctions $this->userFunctions;
  225.         jIncluder::inc($sel);
  226.         $this->_templateName = $sel->toString();
  227.         $fct $fctname.md5($sel->module.'_'.$sel->resource.'_'.$sel->outputType.($trusted?'_t':''));
  228.         $fct($this);
  229.     }
  230.  
  231.     /**
  232.      * return the generated content from the given template
  233.      * @param string $tpl template selector
  234.      * @param string $outputtype the type of output (html, text etc..)
  235.      * @param boolean $trusted  says if the template file is trusted or not
  236.      * @param boolean $callMeta false if meta should not be called
  237.      * @return string the generated content
  238.      */
  239.     public function fetch ($tpl$outputtype=''$trusted true$callMeta=true){
  240.         $content '';
  241.         ob_start ();
  242.         try{
  243.             $sel new jSelectorTpl($tpl$outputtype$trusted);
  244.             $sel->userModifiers $this->userModifiers;
  245.             $sel->userFunctions $this->userFunctions;
  246.             jIncluder::inc($sel);
  247.             $md md5($sel->module.'_'.$sel->resource.'_'.$sel->outputType.($trusted?'_t':''));
  248.             $this->_templateName = $sel->toString();
  249.             if ($callMeta{
  250.                 $fct 'template_meta_'.$md;
  251.                 $fct($this);
  252.             }
  253.             $fct 'template_'.$md;
  254.             $fct($this);
  255.             $content ob_get_clean();
  256.         }catch(Exception $e){
  257.             ob_end_clean();
  258.             throw $e;
  259.         }
  260.         return $content;
  261.     }
  262.  
  263.     /**
  264.      * deprecated function: optimized version of meta() + fetch().
  265.      * Instead use fetch with true as $callMeta parameter.
  266.      * @param string $tpl template selector
  267.      * @param string $outputtype the type of output (html, text etc..)
  268.      * @param boolean $trusted  says if the template file is trusted or not
  269.      * @return string the generated content
  270.      * @deprecated
  271.      */
  272.     public function metaFetch ($tpl$outputtype=''$trusted true){
  273.         return $this->fetch ($tpl$outputtype$trusted,true);
  274.     }
  275.  
  276.  
  277.     protected $userModifiers = array();
  278.  
  279.     /**
  280.      * register a user modifier. The function should accept at least a
  281.      * string as first parameter, and should return this string
  282.      * which can be modified.
  283.      * @param string $name  the name of the modifier in a template
  284.      * @param string $functionName the corresponding PHP function
  285.      * @since jelix 1.1
  286.      */
  287.     public function registerModifier($name$functionName{
  288.         $this->userModifiers[$name$functionName;
  289.     }
  290.  
  291.     protected $userFunctions = array();
  292.  
  293.     /**
  294.      * register a user function. The function should accept a jTpl object
  295.      * as first parameter.
  296.      * @param string $name  the name of the modifier in a template
  297.      * @param string $functionName the corresponding PHP function
  298.      * @since jelix 1.1
  299.      */
  300.     public function registerFunction($name$functionName{
  301.         $this->userFunctions[$name$functionName;
  302.     }
  303.  
  304.     /**
  305.      * return the current encoding
  306.      * @return string the charset string
  307.      * @since 1.0b2
  308.      */
  309.     public static function getEncoding (){
  310.         return $GLOBALS['gJConfig']->charset;
  311.     }
  312. }

Documentation generated on Thu, 22 Mar 2012 22:17:20 +0100 by phpDocumentor 1.4.3