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-2011 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 JELIX_APP_TEMP_PATH.'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.         global $gJConfig;
  162.         
  163.         if ($this->_useCache && !$gJConfig->zones['disableCache']){
  164.             $f $this->_getCacheFile();
  165.             if(file_exists($f)){
  166.                 if($this->_cacheTimeout > 0){
  167.                     clearstatcache();
  168.                     if(time(filemtime($f$this->_cacheTimeout){
  169.                         // timeout : regenerate the cache
  170.                         unlink($f);
  171.                         $this->_cancelCache=false;
  172.                         $content=$this->_createContent();
  173.                         if(!$this->_cancelCache){
  174.                             jFile::write($f,$content);
  175.                         }
  176.                         return $content;
  177.                     }
  178.                 }
  179.                 if($this->_tplname != ''){
  180.                     $this->_tpl = new jTpl();
  181.                     $this->_tpl->assign($this->_params);
  182.                     $this->_tpl->meta($this->_tplname$this->_tplOutputType);
  183.                 }
  184.                 $content file_get_contents($f);
  185.             }else{
  186.                 $this->_cancelCache=false;
  187.                 $content=$this->_createContent();
  188.                 if(!$this->_cancelCache){
  189.                     jFile::write($f,$content);
  190.                 }
  191.             }
  192.         }else{
  193.             $content=$this->_createContent();
  194.         }
  195.         return $content;
  196.     }
  197.  
  198.     /**
  199.     * Delete the cache of the current zone
  200.     */
  201.     public function clearCache (){
  202.         if ($this->_useCache){
  203.             $f $this->_getCacheFile();
  204.             if(file_exists($f)){
  205.                 unlink($f);
  206.             }
  207.         }
  208.     }
  209.  
  210.  
  211.     /**
  212.     * create the content of the zone
  213.     * by default, it uses a template, and so prepare a jtpl object to use in _prepareTpl.
  214.     * zone parameters are automatically assigned in the template
  215.     * If you don't want a template, override it in your class
  216.     * @return string generated content
  217.     */
  218.     protected function _createContent (){
  219.         $this->_tpl = new jTpl();
  220.         $this->_tpl->assign($this->_params);
  221.         $this->_prepareTpl();
  222.         if($this->_tplname == ''return '';
  223.         return $this->_tpl->fetch($this->_tplname$this->_tplOutputType);
  224.     }
  225.  
  226.     /**
  227.      * override this method if you want do additionnal thing on the template object
  228.      * Example : do access to a dao object.. Note : the template object
  229.      * is in the _tpl property
  230.      */
  231.     protected function _prepareTpl(){
  232.  
  233.     }
  234.  
  235.     /**
  236.     * create the cache filename
  237.     * @return string the filename
  238.     */
  239.     private function _getCacheFile (){
  240.         $module jContext::get ();
  241.         $ar $this->_params;
  242.         ksort($ar);
  243.         $id=md5(serialize($ar));
  244.         return JELIX_APP_TEMP_PATH.'zonecache/~'.$module.'~'.strtolower(get_class($this)).'~'.$id.'.php';
  245.     }
  246.  
  247.    /**
  248.     * instancy a zone object, and call one of its methods
  249.     * @param string $name zone selector
  250.     * @param string $method method name
  251.     * @param array  $params arguments for the method
  252.     * @return mixed the result returned by the method
  253.     */
  254.     private static function  _callZone($name,$method&$params){
  255.  
  256.         $sel new jSelectorZone($name);
  257.         jContext::push ($sel->module);
  258.  
  259.         $fileName $sel->getPath();
  260.         require_once($fileName);
  261.         $className $sel->resource.'Zone';
  262.         $zone new $className ($params);
  263.         $toReturn $zone->$method ();
  264.  
  265.         jContext::pop ();
  266.         return $toReturn;
  267.     }
  268.  
  269.     /**
  270.      * @deprecated
  271.      */
  272.     function __set ($name$value{
  273.         if ($name == '_tplOuputType'{
  274.             trigger_error('jZone::_tplOuputType is deprecated (mispelled), use jZone::_tplOutputType instead',E_USER_NOTICE);
  275.             $this->_tplOutputType = $value;
  276.         }
  277.     }
  278.  
  279.     /**
  280.      * @deprecated
  281.      */
  282.     function __get ($name{
  283.         if ($name == '_tplOuputType'{
  284.             trigger_error('jZone::_tplOuputType is deprecated (mispelled), use jZone::_tplOutputType instead',E_USER_NOTICE);
  285.             return $this->_tplOutputType;
  286.         }
  287.     }
  288. }

Documentation generated on Thu, 19 Sep 2013 00:08:10 +0200 by phpDocumentor 1.4.3