Source for file jEvent.class.php

Documentation is available at jEvent.class.php

  1. <?php
  2. /**
  3. @package     jelix
  4. @subpackage  events
  5. @author      Croes GĂ©rald, Patrice Ferlet
  6. @contributor Laurent Jouanneau, Catsoup
  7. @copyright 2001-2005 CopixTeam, 2005-2007 Laurent Jouanneau
  8. *  This classes were get originally from the Copix project
  9. *  (CopixEvent*, CopixListener* from 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  Patrice Ferlet,
  12. *  and this classes were 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.  *
  20.  */
  21. require(JELIX_LIB_PATH.'events/jEventListener.class.php');
  22.  
  23.  
  24. /**
  25. * Class which represents an event in the event system
  26. @package     jelix
  27. @subpackage  events
  28. */
  29. class jEvent {
  30.     /**
  31.     * The name of the event.
  32.     * @var string name
  33.     */
  34.     protected $_name = null;
  35.  
  36.     /**
  37.     * the event parameters
  38.     */
  39.     protected $_params = null;
  40.  
  41.     /**
  42.     * @var array of array
  43.     */
  44.     protected $_responses = array ();
  45.  
  46.     /**
  47.     * New event.
  48.     * @param string $name  the event name
  49.     * @param array $params an associative array which contains parameters for the listeners
  50.     */
  51.     function __construct ($name$params=array()){
  52.         $this->_name   = $name;
  53.         $this->_params = $params;
  54.     }
  55.  
  56.     /**
  57.     * gets the name of the event
  58.     *    will be used internally for optimisations
  59.     */
  60.     public function getName (){
  61.         return $this->_name;
  62.     }
  63.  
  64.     /**
  65.     * gets the given param
  66.     * @param string $name the param name
  67.     */
  68.     public function getParam ($name){
  69.         if (isset ($this->_params[$name])){
  70.             $ret $this->_params[$name];
  71.         }else{
  72.             $ret null;
  73.         }
  74.         return $ret;
  75.     }
  76.  
  77.     /**
  78.     * adds data in the responses list
  79.     * @param array $response a single response
  80.     */
  81.     public function add ($response{
  82.         $this->_responses[$response;
  83.     }
  84.  
  85.     /**
  86.     * look in all the responses if we have a parameter having value as its answer
  87.     * eg, we want to know if we have failed = true, we do
  88.     * @param string $responseName the param we're looking for
  89.     * @param mixed $value the value we're looking for
  90.     * @param ref $response the response that have this value
  91.     * @return boolean wether or not we have founded the response value
  92.     */
  93.     public function inResponse ($responseName$value$response){
  94.         $founded  false;
  95.         $response array ();
  96.  
  97.         foreach ($this->_responses as $key=>$listenerResponse){
  98.             if (isset ($listenerResponse[$responseName]&& $listenerResponse[$responseName== $value){
  99.                 $founded true;
  100.                 $response[$this->_responses[$key];
  101.             }
  102.         }
  103.  
  104.         return $founded;
  105.     }
  106.  
  107.     /**
  108.     * gets all the responses
  109.     * @return array of associative array
  110.     */
  111.     public function getResponse ({
  112.         return $this->_responses;
  113.     }
  114.  
  115.  
  116.    //------------------------------------- static methods
  117.  
  118.  
  119.     /**
  120.     * send a notification to all modules
  121.     * @param $event string   the event name
  122.     * @return jEvent 
  123.     */
  124.     public static function notify ($eventname$params=array()) {
  125.  
  126.         $event new jEvent($eventname$params);
  127.  
  128.         if(!isset(self::$hashListened[$eventname])){
  129.             self::loadListenersFor ($eventname);
  130.         }
  131.  
  132.         $list self::$hashListened[$eventname];
  133.         foreach (array_keys ($listas $key{
  134.             $list[$key]->performEvent ($event);
  135.         }
  136.  
  137.         return $event;
  138.    }
  139.  
  140.     protected static $compilerData array('jEventCompiler',
  141.                     'events/jEventCompiler.class.php',
  142.                     'events.xml',
  143.                     'events.php'
  144.                     );
  145.  
  146.     /**
  147.     * because a listener can listen several events, we should
  148.     * create only one instancy of a listener for performance, and
  149.     * $hashListened will contains only reference to this listener.
  150.     * @var array of jEventListener
  151.     */
  152.     protected static $listenersSingleton array ();
  153.  
  154.     /**
  155.     * hash table for event listened.
  156.     * $_hash['eventName'] = array of events (by reference)
  157.     * @var associative array of object
  158.     */
  159.     protected static $hashListened array ();
  160.  
  161.     /**
  162.     * return the list of all listener corresponding to an event
  163.     * @param string $eventName the event name we wants the listeners for.
  164.     * @return array of objects
  165.     */
  166.     protected static function loadListenersFor ($eventName{
  167.         if (!isset($GLOBALS['JELIX_EVENTS'])) {
  168.             self::$compilerData[3$GLOBALS['gJConfig']->urlengine['urlScriptId'].'.'.self::$compilerData[3];
  169.             jIncluder::incAll(self::$compilerData);
  170.         }
  171.  
  172.         $inf $GLOBALS['JELIX_EVENTS'];
  173.         self::$hashListened[$eventNamearray();
  174.         if(isset($inf[$eventName])){
  175.             $modules $GLOBALS['gJConfig']->_modulesPathList;
  176.             foreach ($inf[$eventNameas $listener){
  177.                 list($module,$listenerName$listener;
  178.                 if (isset($modules[$module]))  // some modules could be unused
  179.                     continue;
  180.                 if (isset (self::$listenersSingleton[$module][$listenerName])){
  181.                     require_once ($modules[$module].'classes/'.$listenerName.'.listener.php');
  182.                     $className $listenerName.'Listener';
  183.         #if ENABLE_OLD_CLASS_NAMING
  184.                     if(!class_exists($className,false)){
  185.                         $className 'Listener'.$listenerName;
  186.                     }
  187.         #endif
  188.                     self::$listenersSingleton[$module][$listenerName=  new $className ();
  189.                 }
  190.                 self::$hashListened[$eventName][self::$listenersSingleton[$module][$listenerName];
  191.             }
  192.         }
  193.     }
  194. }

Documentation generated on Thu, 22 Mar 2012 22:15:26 +0100 by phpDocumentor 1.4.3