Source for file jZone.class.php

Documentation is available at jZone.class.php

  1. <?php
  2. /**
  3. @package    jelix
  4. @subpackage utils
  5. @author     GĂ©rald Croes, Laurent Jouanneau
  6. @contributor Laurent Jouanneau, Laurent Raufaste, Pulsation
  7. @copyright  2001-2005 CopixTeam, 2005-2012 Laurent Jouanneau, 2008 Laurent Raufaste, 2008 Pulsation
  8. *
  9. *  This class was get originally from the Copix project (CopixZone, Copix 2.3dev20050901, http://www.copix.org)
  10. *  Some lines of code are copyrighted 2001-2005 CopixTeam (LGPL licence).
  11. *  Initial authors of this Copix classes are Gerald Croes and Laurent Jouanneau,
  12. *  and this class was adapted/improved for Jelix by Laurent Jouanneau
  13. *
  14. @link        http://www.jelix.org
  15. @licence  http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
  16. */
  17.  
  18. /**
  19.  * jZone is a representation of a zone in an response content, in a html page.
  20.  * A user zone should inherits from jZone. jZone provide a cache mecanism.
  21.  * @package    jelix
  22.  * @subpackage utils
  23.  */
  24. class jZone {
  25.     /**
  26.     * If we're using cache on this zone
  27.     * You should override it in your class if you want activate the cache
  28.     * @var boolean 
  29.     */
  30.     protected $_useCache = false;
  31.  
  32.     /**
  33.      * cache timeout (seconds).
  34.      * set to 0 if you want to delete cache manually.
  35.      * @var integer 
  36.      */
  37.     protected $_cacheTimeout = 0;
  38.  
  39.     /**
  40.     * list of zone parameters
  41.     * @var array 
  42.     */
  43.     protected $_params;
  44.  
  45.     /**
  46.      * template selector
  47.      * If you want to use a template for your zone, set its name in this property
  48.      * in your zone, and override _prepareTpl. Else, keep it to empty string, and
  49.      * override _createContent
  50.      * @var string 
  51.      */
  52.     protected $_tplname='';
  53.  
  54.     /**
  55.      * says the type of the output of the template, in the case of the result
  56.      * of the zone is not used in a response in the same output type.
  57.      * For example, the output type of a ajax response is text, but the template
  58.      * can contains html, so the template should be treated as html content,
  59.      * so you should put 'html' here.
  60.      * If empty, the output type will be the output type of the current response.
  61.      * @var string 
  62.      * @see jTpl::fetch
  63.      */
  64.     protected $_tplOutputType='';
  65.  
  66.     /**
  67.      * the jtpl object created automatically by jZone if you set up _tplname
  68.      * you can use it in _prepareTpl
  69.      * @var jTpl 
  70.      */
  71.     protected $_tpl=null;
  72.  
  73.     /**
  74.      * When the cache system is activated, says if the cache should be generated or not
  75.      * you set it to false in _createContent or _prepareTpl, in specific case.
  76.      * @var boolean 
  77.      */
  78.     protected $_cancelCache=false;
  79.  
  80.     /**
  81.      * constructor.
  82.      */
  83.     function __construct($params=array()){
  84.         $this->_params = $params;
  85.     }
  86.  
  87.     /**
  88.     * get the content of a zone
  89.     * @param string $name zone selector
  90.     * @param array $params parameters for the zone
  91.     * @return string the generated content of the zone
  92.     * @since 1.0b1
  93.     */
  94.     public static function get ($name$params=array ()){
  95.         return self::_callZone($name'getContent'$params);
  96.     }
  97.  
  98.     /**
  99.     * clear a specific cache of a zone
  100.     * @param string $name zone selector
  101.     * @param array $params parameters for the zone
  102.     * @since 1.0b1
  103.     */
  104.     public static function clear ($name$params=array ()){
  105.         return self::_callZone($name'clearCache'$params);
  106.     }
  107.  
  108.     /**
  109.     * clear all zone cache or all cache of a specific zone
  110.     * @param string $name zone selector
  111.     * @since 1.0b1
  112.     */
  113.     public static function clearAll($name=''){
  114.         $dir jApp::tempPath('zonecache/');
  115.         if(!file_exists($dir)) return;
  116.  
  117.         if($name !=''){
  118.             $sel new jSelectorZone($name);
  119.             $fic '~'.$sel->module.'~'.strtolower($sel->resource).'zone~';
  120.         }else{
  121.             $fic '~';
  122.         }
  123.  
  124.         if ($dh opendir($dir)) {
  125.            while (($file readdir($dh)) !== false{
  126.                if(strpos($file$fic=== 0){
  127.                    unlink($dir.$file);
  128.                }
  129.            }
  130.            closedir($dh);
  131.        }
  132.     }
  133.  
  134.     /**
  135.     * gets the value of a parameter, if defined. Returns the default value instead.
  136.     * @param string $paramName the parameter name
  137.     * @param mixed $defaultValue the parameter default value
  138.     * @return mixed the param value
  139.     */
  140.     public function param ($paramName$defaultValue=null){
  141.         return array_key_exists ($paramName$this->_params$this->_params[$paramName$defaultValue;
  142.     }
  143.  
  144.     /**
  145.      * Same as param(), included for compatibility with older versions
  146.      * @param string $paramName the parameter name
  147.      * @param mixed $defaultValue the parameter default value
  148.      * @return mixed the param value
  149.      * @deprecated 1.1
  150.      */
  151.     public function getParam ($paramName$defaultValue=null){
  152.         return $this->param($paramName$defaultValue);
  153.     }
  154.  
  155.     /**
  156.     * get the zone content
  157.     * Return the cache content if it is activated and if it's exists, or call _createContent
  158.     * @return string  zone content
  159.     */
  160.     public function getContent (){
  161.  
  162.         if ($this->_useCache && !jApp::config()->zones['disableCache']){
  163.             $f $this->_getCacheFile();
  164.             if(file_exists($f)){
  165.                 if($this->_cacheTimeout > 0){
  166.                     if (version_compare(PHP_VERSION'5.3.0'>= 0)
  167.                         clearstatcache(false$f);
  168.                     else
  169.                         clearstatcache();
  170.                     if(time(filemtime($f$this->_cacheTimeout){
  171.                         // timeout : regenerate the cache
  172.                         unlink($f);
  173.                         $this->_cancelCache=false;
  174.                         $content=$this->_createContent();
  175.                         if(!$this->_cancelCache){
  176.                             jFile::write($f,$content);
  177.                         }
  178.                         return $content;
  179.                     }
  180.                 }
  181.                 if($this->_tplname != ''){
  182.                     $this->_tpl = new jTpl();
  183.                     $this->_tpl->assign($this->_params);
  184.                     $this->_tpl->meta($this->_tplname$this->_tplOutputType);
  185.                 }
  186.                 $content file_get_contents($f);
  187.             }else{
  188.                 $this->_cancelCache=false;
  189.                 $content=$this->_createContent();
  190.                 if(!$this->_cancelCache){
  191.                     jFile::write($f,$content);
  192.                 }
  193.             }
  194.         }else{
  195.             $content=$this->_createContent();
  196.         }
  197.         return $content;
  198.     }
  199.  
  200.     /**
  201.     * Delete the cache of the current zone
  202.     */
  203.     public function clearCache (){
  204.         if ($this->_useCache){
  205.             $f $this->_getCacheFile();
  206.             if(file_exists($f)){
  207.                 unlink($f);
  208.             }
  209.         }
  210.     }
  211.  
  212.  
  213.     /**
  214.     * create the content of the zone
  215.     * by default, it uses a template, and so prepare a jtpl object to use in _prepareTpl.
  216.     * zone parameters are automatically assigned in the template
  217.     * If you don't want a template, override it in your class
  218.     * @return string generated content
  219.     */
  220.     protected function _createContent (){
  221.         $this->_tpl = new jTpl();
  222.         $this->_tpl->assign($this->_params);
  223.         $this->_prepareTpl();
  224.         if($this->_tplname == ''return '';
  225.         return $this->_tpl->fetch($this->_tplname$this->_tplOutputType);
  226.     }
  227.  
  228.     /**
  229.      * override this method if you want do additionnal thing on the template object
  230.      * Example : do access to a dao object.. Note : the template object
  231.      * is in the _tpl property
  232.      */
  233.     protected function _prepareTpl(){
  234.  
  235.     }
  236.  
  237.     /**
  238.     * create the cache filename
  239.     * @return string the filename
  240.     */
  241.     private function _getCacheFile (){
  242.         $module jContext::get ();
  243.         $ar $this->_params;
  244.         ksort($ar);
  245.         $id=md5(serialize($ar));
  246.         return jApp::tempPath('zonecache/~'.$module.'~'.strtolower(get_class($this)).'~'.$id.'.php');
  247.     }
  248.  
  249.    /**
  250.     * instancy a zone object, and call one of its methods
  251.     * @param string $name zone selector
  252.     * @param string $method method name
  253.     * @param array  $params arguments for the method
  254.     * @return mixed the result returned by the method
  255.     */
  256.     private static function  _callZone($name,$method&$params){
  257.  
  258.         $sel new jSelectorZone($name);
  259.         jContext::push ($sel->module);
  260.  
  261.         $fileName $sel->getPath();
  262.         require_once($fileName);
  263.         $className $sel->resource.'Zone';
  264.         $zone new $className ($params);
  265.         $toReturn $zone->$method ();
  266.  
  267.         jContext::pop ();
  268.         return $toReturn;
  269.     }
  270.  
  271.     /**
  272.      * @deprecated
  273.      */
  274.     function __set ($name$value{
  275.         if ($name == '_tplOuputType'{
  276.             trigger_error('jZone::_tplOuputType is deprecated (mispelled), use jZone::_tplOutputType instead',E_USER_NOTICE);
  277.             $this->_tplOutputType = $value;
  278.         }
  279.     }
  280.  
  281.     /**
  282.      * @deprecated
  283.      */
  284.     function __get ($name{
  285.         if ($name == '_tplOuputType'{
  286.             trigger_error('jZone::_tplOuputType is deprecated (mispelled), use jZone::_tplOutputType instead',E_USER_NOTICE);
  287.             return $this->_tplOutputType;
  288.         }
  289.     }
  290. }

Documentation generated on Mon, 26 Oct 2015 21:57:00 +0100 by phpDocumentor 1.4.3