source: trunk/admin/inc/ckeditor/_source/core/event.js@ 239

Last change on this file since 239 was 239, checked in by luc, 9 years ago

Admin: correzione visulaizzazione immissione dati spoglio per Chrome e Safari - Aggiornamento dell'editor da FCKeditor a CKeditor , accessibili anche a Chrome e Safari.
  • Property svn:executable set to *
File size: 11.1 KB
Line 
1/*
2Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
3For licensing, see LICENSE.html or http://ckeditor.com/license
4*/
5
6/**
7 * @fileOverview Defines the {@link CKEDITOR.event} class, which serves as the
8 * base for classes and objects that require event handling features.
9 */
10
11if ( !CKEDITOR.event )
12{
13 /**
14 * Creates an event class instance. This constructor is rearely used, being
15 * the {@link #.implementOn} function used in class prototypes directly
16 * instead.
17 * @class This is a base class for classes and objects that require event
18 * handling features.<br />
19 * <br />
20 * Do not confuse this class with {@link CKEDITOR.dom.event} which is
21 * instead used for DOM events. The CKEDITOR.event class implements the
22 * internal event system used by the CKEditor to fire API related events.
23 * @example
24 */
25 CKEDITOR.event = function()
26 {};
27
28 /**
29 * Implements the {@link CKEDITOR.event} features in an object.
30 * @param {Object} targetObject The object into which implement the features.
31 * @example
32 * var myObject = { message : 'Example' };
33 * <b>CKEDITOR.event.implementOn( myObject }</b>;
34 * myObject.on( 'testEvent', function()
35 * {
36 * alert( this.message ); // "Example"
37 * });
38 * myObject.fire( 'testEvent' );
39 */
40 CKEDITOR.event.implementOn = function( targetObject )
41 {
42 var eventProto = CKEDITOR.event.prototype;
43
44 for ( var prop in eventProto )
45 {
46 if ( targetObject[ prop ] == undefined )
47 targetObject[ prop ] = eventProto[ prop ];
48 }
49 };
50
51 CKEDITOR.event.prototype = (function()
52 {
53 // Returns the private events object for a given object.
54 var getPrivate = function( obj )
55 {
56 var _ = ( obj.getPrivate && obj.getPrivate() ) || obj._ || ( obj._ = {} );
57 return _.events || ( _.events = {} );
58 };
59
60 var eventEntry = function( eventName )
61 {
62 this.name = eventName;
63 this.listeners = [];
64 };
65
66 eventEntry.prototype =
67 {
68 // Get the listener index for a specified function.
69 // Returns -1 if not found.
70 getListenerIndex : function( listenerFunction )
71 {
72 for ( var i = 0, listeners = this.listeners ; i < listeners.length ; i++ )
73 {
74 if ( listeners[i].fn == listenerFunction )
75 return i;
76 }
77 return -1;
78 }
79 };
80
81 return /** @lends CKEDITOR.event.prototype */ {
82 /**
83 * Registers a listener to a specific event in the current object.
84 * @param {String} eventName The event name to which listen.
85 * @param {Function} listenerFunction The function listening to the
86 * event. A single {@link CKEDITOR.eventInfo} object instanced
87 * is passed to this function containing all the event data.
88 * @param {Object} [scopeObj] The object used to scope the listener
89 * call (the this object. If omitted, the current object is used.
90 * @param {Object} [listenerData] Data to be sent as the
91 * {@link CKEDITOR.eventInfo#listenerData} when calling the
92 * listener.
93 * @param {Number} [priority] The listener priority. Lower priority
94 * listeners are called first. Listeners with the same priority
95 * value are called in registration order. Defaults to 10.
96 * @example
97 * someObject.on( 'someEvent', function()
98 * {
99 * alert( this == someObject ); // "true"
100 * });
101 * @example
102 * someObject.on( 'someEvent', function()
103 * {
104 * alert( this == anotherObject ); // "true"
105 * }
106 * , anotherObject );
107 * @example
108 * someObject.on( 'someEvent', function( event )
109 * {
110 * alert( event.listenerData ); // "Example"
111 * }
112 * , null, 'Example' );
113 * @example
114 * someObject.on( 'someEvent', function() { ... } ); // 2nd called
115 * someObject.on( 'someEvent', function() { ... }, null, null, 100 ); // 3rd called
116 * someObject.on( 'someEvent', function() { ... }, null, null, 1 ); // 1st called
117 */
118 on : function( eventName, listenerFunction, scopeObj, listenerData, priority )
119 {
120 // Get the event entry (create it if needed).
121 var events = getPrivate( this ),
122 event = events[ eventName ] || ( events[ eventName ] = new eventEntry( eventName ) );
123
124 if ( event.getListenerIndex( listenerFunction ) < 0 )
125 {
126 // Get the listeners.
127 var listeners = event.listeners;
128
129 // Fill the scope.
130 if ( !scopeObj )
131 scopeObj = this;
132
133 // Default the priority, if needed.
134 if ( isNaN( priority ) )
135 priority = 10;
136
137 var me = this;
138
139 // Create the function to be fired for this listener.
140 var listenerFirer = function( editor, publisherData, stopFn, cancelFn )
141 {
142 var ev =
143 {
144 name : eventName,
145 sender : this,
146 editor : editor,
147 data : publisherData,
148 listenerData : listenerData,
149 stop : stopFn,
150 cancel : cancelFn,
151 removeListener : function()
152 {
153 me.removeListener( eventName, listenerFunction );
154 }
155 };
156
157 listenerFunction.call( scopeObj, ev );
158
159 return ev.data;
160 };
161 listenerFirer.fn = listenerFunction;
162 listenerFirer.priority = priority;
163
164 // Search for the right position for this new listener, based on its
165 // priority.
166 for ( var i = listeners.length - 1 ; i >= 0 ; i-- )
167 {
168 // Find the item which should be before the new one.
169 if ( listeners[ i ].priority <= priority )
170 {
171 // Insert the listener in the array.
172 listeners.splice( i + 1, 0, listenerFirer );
173 return;
174 }
175 }
176
177 // If no position has been found (or zero length), put it in
178 // the front of list.
179 listeners.unshift( listenerFirer );
180 }
181 },
182
183 /**
184 * Fires an specific event in the object. All registered listeners are
185 * called at this point.
186 * @function
187 * @param {String} eventName The event name to fire.
188 * @param {Object} [data] Data to be sent as the
189 * {@link CKEDITOR.eventInfo#data} when calling the
190 * listeners.
191 * @param {CKEDITOR.editor} [editor] The editor instance to send as the
192 * {@link CKEDITOR.eventInfo#editor} when calling the
193 * listener.
194 * @returns {Boolean|Object} A booloan indicating that the event is to be
195 * canceled, or data returned by one of the listeners.
196 * @example
197 * someObject.on( 'someEvent', function() { ... } );
198 * someObject.on( 'someEvent', function() { ... } );
199 * <b>someObject.fire( 'someEvent' )</b>; // both listeners are called
200 * @example
201 * someObject.on( 'someEvent', function( event )
202 * {
203 * alert( event.data ); // "Example"
204 * });
205 * <b>someObject.fire( 'someEvent', 'Example' )</b>;
206 */
207 fire : (function()
208 {
209 // Create the function that marks the event as stopped.
210 var stopped = false;
211 var stopEvent = function()
212 {
213 stopped = true;
214 };
215
216 // Create the function that marks the event as canceled.
217 var canceled = false;
218 var cancelEvent = function()
219 {
220 canceled = true;
221 };
222
223 return function( eventName, data, editor )
224 {
225 // Get the event entry.
226 var event = getPrivate( this )[ eventName ];
227
228 // Save the previous stopped and cancelled states. We may
229 // be nesting fire() calls.
230 var previousStopped = stopped,
231 previousCancelled = canceled;
232
233 // Reset the stopped and canceled flags.
234 stopped = canceled = false;
235
236 if ( event )
237 {
238 var listeners = event.listeners;
239
240 if ( listeners.length )
241 {
242 // As some listeners may remove themselves from the
243 // event, the original array length is dinamic. So,
244 // let's make a copy of all listeners, so we are
245 // sure we'll call all of them.
246 listeners = listeners.slice( 0 );
247
248 // Loop through all listeners.
249 for ( var i = 0 ; i < listeners.length ; i++ )
250 {
251 // Call the listener, passing the event data.
252 var retData = listeners[i].call( this, editor, data, stopEvent, cancelEvent );
253
254 if ( typeof retData != 'undefined' )
255 data = retData;
256
257 // No further calls is stopped or canceled.
258 if ( stopped || canceled )
259 break;
260 }
261 }
262 }
263
264 var ret = canceled || ( typeof data == 'undefined' ? false : data );
265
266 // Restore the previous stopped and canceled states.
267 stopped = previousStopped;
268 canceled = previousCancelled;
269
270 return ret;
271 };
272 })(),
273
274 /**
275 * Fires an specific event in the object, releasing all listeners
276 * registered to that event. The same listeners are not called again on
277 * successive calls of it or of {@link #fire}.
278 * @param {String} eventName The event name to fire.
279 * @param {Object} [data] Data to be sent as the
280 * {@link CKEDITOR.eventInfo#data} when calling the
281 * listeners.
282 * @param {CKEDITOR.editor} [editor] The editor instance to send as the
283 * {@link CKEDITOR.eventInfo#editor} when calling the
284 * listener.
285 * @returns {Boolean|Object} A booloan indicating that the event is to be
286 * canceled, or data returned by one of the listeners.
287 * @example
288 * someObject.on( 'someEvent', function() { ... } );
289 * someObject.fire( 'someEvent' ); // above listener called
290 * <b>someObject.fireOnce( 'someEvent' )</b>; // above listener called
291 * someObject.fire( 'someEvent' ); // no listeners called
292 */
293 fireOnce : function( eventName, data, editor )
294 {
295 var ret = this.fire( eventName, data, editor );
296 delete getPrivate( this )[ eventName ];
297 return ret;
298 },
299
300 /**
301 * Unregisters a listener function from being called at the specified
302 * event. No errors are thrown if the listener has not been
303 * registered previously.
304 * @param {String} eventName The event name.
305 * @param {Function} listenerFunction The listener function to unregister.
306 * @example
307 * var myListener = function() { ... };
308 * someObject.on( 'someEvent', myListener );
309 * someObject.fire( 'someEvent' ); // myListener called
310 * <b>someObject.removeListener( 'someEvent', myListener )</b>;
311 * someObject.fire( 'someEvent' ); // myListener not called
312 */
313 removeListener : function( eventName, listenerFunction )
314 {
315 // Get the event entry.
316 var event = getPrivate( this )[ eventName ];
317
318 if ( event )
319 {
320 var index = event.getListenerIndex( listenerFunction );
321 if ( index >= 0 )
322 event.listeners.splice( index, 1 );
323 }
324 },
325
326 /**
327 * Checks if there is any listener registered to a given event.
328 * @param {String} eventName The event name.
329 * @example
330 * var myListener = function() { ... };
331 * someObject.on( 'someEvent', myListener );
332 * alert( someObject.<b>hasListeners( 'someEvent' )</b> ); // "true"
333 * alert( someObject.<b>hasListeners( 'noEvent' )</b> ); // "false"
334 */
335 hasListeners : function( eventName )
336 {
337 var event = getPrivate( this )[ eventName ];
338 return ( event && event.listeners.length > 0 ) ;
339 }
340 };
341 })();
342}
Note: See TracBrowser for help on using the repository browser.