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-2012 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.     /**
  21.      * all assigned template variables.
  22.      * It have a public access only for plugins. So you musn't use directly this property
  23.      * except from tpl plugins.
  24.      * See methods of jTpl to manage template variables
  25.      * @var array 
  26.      */
  27.     public $_vars = array ();
  28.  
  29.     /**
  30.      * temporary template variables for plugins.
  31.      * It have a public access only for plugins. So you musn't use directly this property
  32.      * except from tpl plugins.
  33.      * @var array 
  34.      */
  35.     public $_privateVars = array ();
  36.  
  37.     /**
  38.      * internal use
  39.      * It have a public access only for plugins. So you musn't use directly this property
  40.      * except from tpl plugins.
  41.      * @var array 
  42.      */
  43.     public $_meta = array();
  44.  
  45.     public function __construct ({
  46.         $config jApp::config();
  47.         $this->_vars['j_basepath'$config->urlengine['basePath'];
  48.         $this->_vars['j_jelixwww'$config->urlengine['jelixWWWPath'];
  49.         $this->_vars['j_jquerypath'$config->urlengine['jqueryPath'];
  50.         $this->_vars['j_themepath'$config->urlengine['basePath'].'themes/'.$config->theme.'/';
  51.         $this->_vars['j_locale'$config->locale;
  52.         $this->_vars['j_datenow'date('Y-m-d');
  53.         $this->_vars['j_timenow'date('H:i:s');
  54.     }
  55.  
  56.     /**
  57.      * assign a value in a template variable
  58.      * @param string|array$name the variable name, or an associative array 'name'=>'value'
  59.      * @param mixed  $value the value (or null if $name is an array)
  60.      */
  61.     public function assign ($name$value null{
  62.         if (is_array($name)) {
  63.             $this->_vars = array_merge($this->_vars$name);
  64.         else {
  65.             $this->_vars[$name$value;
  66.         }
  67.     }
  68.  
  69.     /**
  70.      * assign a value by reference in a template variable
  71.      * @param string $name the variable name
  72.      * @param mixed  $value the value
  73.      * @since jelix 1.1
  74.      */
  75.     public function assignByRef ($name$value{
  76.         $this->_vars[$name&$value;
  77.     }
  78.  
  79.     /**
  80.      * concat a value in with a value of an existing template variable
  81.      * @param string|array$name the variable name, or an associative array 'name'=>'value'
  82.      * @param mixed  $value the value (or null if $name is an array)
  83.      */
  84.     public function append ($name$value null{
  85.         if (is_array($name)) {
  86.             foreach ($name as $key => $val{
  87.                 if (isset($this->_vars[$key]))
  88.                     $this->_vars[$key.= $val;
  89.                 else
  90.                     $this->_vars[$key$val;
  91.             }
  92.         else {
  93.             if (isset($this->_vars[$name]))
  94.                 $this->_vars[$name.= $value;
  95.             else
  96.                 $this->_vars[$name$value;
  97.         }
  98.     }
  99.  
  100.     /**
  101.      * assign a value in a template variable, only if the template variable doesn't exist
  102.      * @param string|array$name the variable name, or an associative array 'name'=>'value'
  103.      * @param mixed  $value the value (or null if $name is an array)
  104.      */
  105.     public function assignIfNone ($name$value null{
  106.         if (is_array($name)) {
  107.             foreach ($name as $key => $val{
  108.                 if (!isset($this->_vars[$key]))
  109.                     $this->_vars[$key$val;
  110.             }
  111.         else {
  112.             if (!isset($this->_vars[$name]))
  113.                 $this->_vars[$name$value;
  114.         }
  115.     }
  116.  
  117.     /**
  118.      * assign a zone content to a template variable
  119.      * @param string $name the variable name
  120.      * @param string $zoneName  a zone selector
  121.      * @param array  $params  parameters for the zone
  122.      * @see jZone
  123.      */
  124.     function assignZone ($name$zoneName$params array()) {
  125.         $this->_vars[$namejZone::get ($zoneName$params);
  126.     }
  127.  
  128.     /**
  129.      * append a zone content to a template variable
  130.      * @param string $name the variable name
  131.      * @param string $zoneName  a zone selector
  132.      * @param array  $params  parameters for the zone
  133.      * @see jZone
  134.      * @since 1.0
  135.      */
  136.     function appendZone ($name$zoneName$params array()) {
  137.         if (isset($this->_vars[$name]))
  138.             $this->_vars[$name.= jZone::get ($zoneName$params);
  139.         else
  140.             $this->_vars[$namejZone::get ($zoneName$params);
  141.     }
  142.  
  143.     /**
  144.      * assign a zone content to a template variable only if this variable doesn't exist
  145.      * @param string $name the variable name
  146.      * @param string $zoneName  a zone selector
  147.      * @param array  $params  parameters for the zone
  148.      * @see jZone
  149.      */
  150.     function assignZoneIfNone ($name$zoneName$params array()) {
  151.         if (!isset($this->_vars[$name]))
  152.             $this->_vars[$namejZone::get ($zoneName$params);
  153.     }
  154.  
  155.     /**
  156.      * says if a template variable exists
  157.      * @param string $name the variable template name
  158.      * @return boolean true if the variable exists
  159.      */
  160.     public function isAssigned ($name{
  161.         return isset($this->_vars[$name]);
  162.     }
  163.  
  164.     /**
  165.      * return the value of a template variable
  166.      * @param string $name the variable template name
  167.      * @return mixed the value (or null if it isn't exist)
  168.      */
  169.     public function get ($name{
  170.         if (isset ($this->_vars[$name])) {
  171.             return $this->_vars[$name];
  172.         else {
  173.             $return null;
  174.             return $return;
  175.         }
  176.     }
  177.  
  178.     /**
  179.      * Return all template variables
  180.      * @return array 
  181.      */
  182.     public function getTemplateVars ({
  183.         return $this->_vars;
  184.     }
  185.  
  186.     /**
  187.      * process all meta instruction of a template
  188.      * @param string $tpl template selector
  189.      * @param string $outputtype the type of output (html, text etc..)
  190.      * @param boolean $trusted  says if the template file is trusted or not
  191.      */
  192.     public function meta ($tpl$outputtype ''$trusted true{
  193.         $sel new jSelectorTpl($tpl,$outputtype,$trusted);
  194.         $tpl $sel->toString();
  195.         if (in_array($tpl$this->processedMeta)) {
  196.             // we want to process meta only one time, when a template is included
  197.             // several time in an other template, or, more important, when a template
  198.             // is included in a recursive manner (in this case, it did cause infinite loop, see #1396). 
  199.             return $this->_meta;
  200.         }
  201.         $this->processedMeta[$tpl;
  202.         $md $this->getTemplate ($sel$outputtype$trusted);
  203.         $fct 'template_meta_'.$md;
  204.         $fct($this);
  205.  
  206.         return $this->_meta;
  207.     }
  208.  
  209.     /**
  210.      * display the generated content from the given template
  211.      * @param string $tpl template selector
  212.      * @param string $outputtype the type of output (html, text etc..)
  213.      * @param boolean $trusted  says if the template file is trusted or not
  214.      */
  215.     public function display ($tpl$outputtype ''$trusted true{
  216.         $sel new jSelectorTpl($tpl,$outputtype,$trusted);
  217.         $tpl $sel->toString();
  218.         $previousTpl $this->_templateName;
  219.         $this->_templateName = $tpl;
  220.         $this->recursiveTpl[$tpl;
  221.         $md $this->getTemplate ($sel$outputtype$trusted);
  222.         $fct 'template_'.$md;
  223.         $fct($this);
  224.         array_pop($this->recursiveTpl);
  225.         $this->_templateName = $previousTpl;
  226.     }
  227.  
  228.     /**
  229.      * contains the name of the template file
  230.      * It have a public access only for plugins. So you musn't use directly this property
  231.      * except from tpl plugins.
  232.      * @var string 
  233.      * @since 1.1
  234.      */
  235.     public $_templateName;
  236.  
  237.     protected $recursiveTpl = array();
  238.     protected $processedMeta = array();
  239.  
  240.     /**
  241.      * include the compiled template file and call one of the generated function
  242.      * @param string|jSelectorTpl$tpl template selector
  243.      * @param string $outputtype the type of output (html, text etc..)
  244.      * @param boolean $trusted  says if the template file is trusted or not
  245.      * @return string the suffix name of the function to call
  246.      */
  247.     protected function getTemplate ($tpl$outputtype ''$trusted true{
  248.         $tpl->userModifiers $this->userModifiers;
  249.         $tpl->userFunctions $this->userFunctions;
  250.         jIncluder::inc($tpl);
  251.         return md5($tpl->module.'_'.$tpl->resource.'_'.$tpl->outputType.($trusted?'_t':''));
  252.     }
  253.  
  254.     /**
  255.      * return the generated content from the given template
  256.      * @param string $tpl template selector
  257.      * @param string $outputtype the type of output (html, text etc..)
  258.      * @param boolean $trusted  says if the template file is trusted or not
  259.      * @param boolean $callMeta false if meta should not be called
  260.      * @return string the generated content
  261.      */
  262.     public function fetch ($tpl$outputtype=''$trusted true$callMeta=true{
  263.         $content '';
  264.         ob_start ();
  265.         try{
  266.             $sel new jSelectorTpl($tpl$outputtype$trusted);
  267.             $tpl $sel->toString();
  268.             $previousTpl $this->_templateName;
  269.             $this->_templateName = $tpl;
  270.             if ($callMeta{
  271.                 if (in_array($tpl$this->processedMeta)) {
  272.                     $callMeta false;
  273.                 }
  274.                 else
  275.                     $this->processedMeta[$tpl;
  276.             }
  277.             $this->recursiveTpl[$tpl;
  278.             $md $this->getTemplate ($sel$outputtype$trusted);
  279.             if ($callMeta{
  280.                 $fct 'template_meta_'.$md;
  281.                 $fct($this);
  282.             }
  283.             $fct 'template_'.$md;
  284.             $fct($this);
  285.             array_pop($this->recursiveTpl);
  286.             $this->_templateName = $previousTpl;
  287.             $content ob_get_clean();
  288.  
  289.         catch(Exception $e{
  290.             ob_end_clean();
  291.             throw $e;
  292.         }
  293.         return $content;
  294.     }
  295.  
  296.      /**
  297.      * Return the generated content from the given string template (virtual)
  298.      * @param string $tpl template content
  299.      * @param string $outputtype the type of output (html, text etc..)
  300.      * @param boolean $trusted  says if the template file is trusted or not
  301.      * @param boolean $callMeta false if meta should not be called
  302.      * @return string the generated content
  303.      */
  304.     public function fetchFromString ($tpl$outputtype=''$trusted true$callMeta=true){
  305.         $content '';
  306.         ob_start ();
  307.         try{
  308.             $cachePath jApp::tempPath('compiled/templates/virtuals/');
  309.             require_once(JELIX_LIB_PATH.'tpl/jTplCompiler.class.php');
  310.             $previousTpl $this->_templateName;
  311.             $md 'virtual_'.md5($tpl).($trusted?'_t':'');
  312.             $this->_templateName = $md;
  313.  
  314.             if ($outputtype == '')
  315.                 $outputtype 'html';
  316.  
  317.             $cachePath .= $outputtype.'_'.$this->_templateName.'.php';
  318.             $mustCompile jApp::config()->compilation['force'|| !file_exists($cachePath);
  319.  
  320.             if ($mustCompile && !function_exists('template_'.$md)) {
  321.                 $compiler new jTplCompiler();
  322.                 $compiler->outputType $outputtype;
  323.                 $compiler->trusted $trusted;
  324.                 $compiler->compileString($tpl$cachePath$this->userModifiers$this->userFunctions$md);
  325.             }
  326.             require_once($cachePath);
  327.  
  328.             if ($callMeta{
  329.                 $fct 'template_meta_'.$md;
  330.                 $fct($this);
  331.             }
  332.             $fct 'template_'.$md;
  333.             $fct($this);
  334.             $content ob_get_clean();
  335.             $this->_templateName = $previousTpl;
  336.         }catch(exception $e){
  337.             ob_end_clean();
  338.             throw $e;
  339.         }
  340.         return $content;
  341.     }
  342.  
  343.     protected $userModifiers = array();
  344.  
  345.     /**
  346.      * register a user modifier. The function should accept at least a
  347.      * string as first parameter, and should return this string
  348.      * which can be modified.
  349.      * @param string $name  the name of the modifier in a template
  350.      * @param string $functionName the corresponding PHP function
  351.      * @since jelix 1.1
  352.      */
  353.     public function registerModifier ($name$functionName{
  354.         $this->userModifiers[$name$functionName;
  355.     }
  356.  
  357.     protected $userFunctions = array();
  358.  
  359.     /**
  360.      * register a user function. The function should accept a jTpl object
  361.      * as first parameter.
  362.      * @param string $name  the name of the modifier in a template
  363.      * @param string $functionName the corresponding PHP function
  364.      * @since jelix 1.1
  365.      */
  366.     public function registerFunction ($name$functionName{
  367.         $this->userFunctions[$name$functionName;
  368.     }
  369.  
  370.     /**
  371.      * return the current encoding
  372.      * @return string the charset string
  373.      * @since 1.0b2
  374.      */
  375.     public static function getEncoding ({
  376.         return jApp::config()->charset;
  377.     }
  378.  
  379. }

Documentation generated on Wed, 04 Jan 2017 22:57:02 +0100 by phpDocumentor 1.4.3