Source for file jEvent.class.php

Documentation is available at jEvent.class.php

1. <?php
2. /**
3. * @package     jelix
4. * @subpackage  events
5. * @author      Gérald Croes, Patrice Ferlet
6. * @contributor Laurent Jouanneau, Dominique Papin, Steven Jehannet
7. * @copyright 2001-2005 CopixTeam, 2005-2012 Laurent Jouanneau, 2009 Dominique Papin
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 string $event 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 ($list) as $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] = jApp::config()->urlengine['urlScriptId'].'.'.self::$compilerData[3];
169.             jIncluder::incAll(self::$compilerData);
170.         }
171.  
172.         $inf = & $GLOBALS['JELIX_EVENTS'];
173.         self::$hashListened[$eventName] = array();
174.         if(isset($inf[$eventName])){
175.             $modules = & jApp::config()->_modulesPathList;
176.             foreach ($inf[$eventName] as $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.                     self::$listenersSingleton[$module][$listenerName] =  new $className ();
184.                 }
185.                 self::$hashListened[$eventName][] = self::$listenersSingleton[$module][$listenerName];
186.             }
187.         }
188.     }
189. }

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