477 lines
16 KiB
JavaScript
477 lines
16 KiB
JavaScript
|
/*
|
||
|
|
* Ext JS Library 2.3.0
|
||
|
|
* Copyright(c) 2006-2009, Ext JS, LLC.
|
||
|
|
* licensing@extjs.com
|
||
|
|
*
|
||
|
|
* http://extjs.com/license
|
||
|
|
*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @class Ext.util.Observable
|
||
|
|
* Abstract base class that provides a common interface for publishing events. Subclasses are expected to
|
||
|
|
* to have a property "events" with all the events defined.<br>
|
||
|
|
* For example:
|
||
|
|
* <pre><code>
|
||
|
|
Employee = function(name){
|
||
|
|
this.name = name;
|
||
|
|
this.addEvents({
|
||
|
|
"fired" : true,
|
||
|
|
"quit" : true
|
||
|
|
});
|
||
|
|
}
|
||
|
|
Ext.extend(Employee, Ext.util.Observable);
|
||
|
|
</code></pre>
|
||
|
|
*/
|
||
|
|
Ext.util.Observable = function(){
|
||
|
|
/**
|
||
|
|
* @cfg {Object} listeners (optional) A config object containing one or more event handlers to be added to this
|
||
|
|
* object during initialization. This should be a valid listeners config object as specified in the
|
||
|
|
* {@link #addListener} example for attaching multiple handlers at once.
|
||
|
|
*/
|
||
|
|
if(this.listeners){
|
||
|
|
this.on(this.listeners);
|
||
|
|
delete this.listeners;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Ext.util.Observable.prototype = {
|
||
|
|
/**
|
||
|
|
* Fires the specified event with the passed parameters (minus the event name).
|
||
|
|
* @param {String} eventName
|
||
|
|
* @param {Object...} args Variable number of parameters are passed to handlers
|
||
|
|
* @return {Boolean} returns false if any of the handlers return false otherwise it returns true
|
||
|
|
*/
|
||
|
|
fireEvent : function(){
|
||
|
|
if(this.eventsSuspended !== true){
|
||
|
|
var ce = this.events[arguments[0].toLowerCase()];
|
||
|
|
if(typeof ce == "object"){
|
||
|
|
return ce.fire.apply(ce, Array.prototype.slice.call(arguments, 1));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
// private
|
||
|
|
filterOptRe : /^(?:scope|delay|buffer|single)$/,
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Appends an event handler to this component
|
||
|
|
* @param {String} eventName The type of event to listen for
|
||
|
|
* @param {Function} handler The method the event invokes
|
||
|
|
* @param {Object} scope (optional) The scope (<code><b>this</b></code> reference) in which the handler function is executed.
|
||
|
|
* <b>If omitted, defaults to the object which fired the event.</b>
|
||
|
|
* @param {Object} options (optional) An object containing handler configuration
|
||
|
|
* properties. This may contain any of the following properties:<ul>
|
||
|
|
* <li><b>scope</b> : Object<div class="sub-desc">The scope (<code><b>this</b></code> reference) in which the handler function is executed.
|
||
|
|
* <b>If omitted, defaults to the object which fired the event.</b></div></li>
|
||
|
|
* <li><b>delay</b> : Number<div class="sub-desc">The number of milliseconds to delay the invocation of the handler after the event fires.</div></li>
|
||
|
|
* <li><b>single</b> : Boolean<div class="sub-desc">True to add a handler to handle just the next firing of the event, and then remove itself.</div></li>
|
||
|
|
* <li><b>buffer</b> : Number<div class="sub-desc">Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
|
||
|
|
* by the specified number of milliseconds. If the event fires again within that time, the original
|
||
|
|
* handler is <em>not</em> invoked, but the new handler is scheduled in its place.</div></li>
|
||
|
|
* <li><b>target</b> : Observable<div class="sub-desc">Only call the handler if the event was fired on the target Observable, <i>not</i>
|
||
|
|
* if the event was bubbled up from a child Observable.</div></li>
|
||
|
|
* </ul><br>
|
||
|
|
* <p>
|
||
|
|
* <b>Combining Options</b><br>
|
||
|
|
* Using the options argument, it is possible to combine different types of listeners:<br>
|
||
|
|
* <br>
|
||
|
|
* A delayed, one-time listener.
|
||
|
|
* <pre><code>
|
||
|
|
myDataView.on('click', this.onClick, this, {
|
||
|
|
single: true,
|
||
|
|
delay: 100
|
||
|
|
});</code></pre>
|
||
|
|
* <p>
|
||
|
|
* <b>Attaching multiple handlers in 1 call</b><br>
|
||
|
|
* The method also allows for a single argument to be passed which is a config object containing properties
|
||
|
|
* which specify multiple handlers.
|
||
|
|
* <p>
|
||
|
|
* <pre><code>
|
||
|
|
myGridPanel.on({
|
||
|
|
'click' : {
|
||
|
|
fn: this.onClick,
|
||
|
|
scope: this,
|
||
|
|
delay: 100
|
||
|
|
},
|
||
|
|
'mouseover' : {
|
||
|
|
fn: this.onMouseOver,
|
||
|
|
scope: this
|
||
|
|
},
|
||
|
|
'mouseout' : {
|
||
|
|
fn: this.onMouseOut,
|
||
|
|
scope: this
|
||
|
|
}
|
||
|
|
});</code></pre>
|
||
|
|
* <p>
|
||
|
|
* Or a shorthand syntax:<br>
|
||
|
|
* <pre><code>
|
||
|
|
myGridPanel.on({
|
||
|
|
'click' : this.onClick,
|
||
|
|
'mouseover' : this.onMouseOver,
|
||
|
|
'mouseout' : this.onMouseOut,
|
||
|
|
scope: this
|
||
|
|
});</code></pre>
|
||
|
|
*/
|
||
|
|
addListener : function(eventName, fn, scope, o){
|
||
|
|
if(typeof eventName == "object"){
|
||
|
|
o = eventName;
|
||
|
|
for(var e in o){
|
||
|
|
if(this.filterOptRe.test(e)){
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if(typeof o[e] == "function"){
|
||
|
|
// shared options
|
||
|
|
this.addListener(e, o[e], o.scope, o);
|
||
|
|
}else{
|
||
|
|
// individual options
|
||
|
|
this.addListener(e, o[e].fn, o[e].scope, o[e]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
o = (!o || typeof o == "boolean") ? {} : o;
|
||
|
|
eventName = eventName.toLowerCase();
|
||
|
|
var ce = this.events[eventName] || true;
|
||
|
|
if(typeof ce == "boolean"){
|
||
|
|
ce = new Ext.util.Event(this, eventName);
|
||
|
|
this.events[eventName] = ce;
|
||
|
|
}
|
||
|
|
ce.addListener(fn, scope, o);
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes a listener
|
||
|
|
* @param {String} eventName The type of event to listen for
|
||
|
|
* @param {Function} handler The handler to remove
|
||
|
|
* @param {Object} scope (optional) The scope (this object) for the handler
|
||
|
|
*/
|
||
|
|
removeListener : function(eventName, fn, scope){
|
||
|
|
var ce = this.events[eventName.toLowerCase()];
|
||
|
|
if(typeof ce == "object"){
|
||
|
|
ce.removeListener(fn, scope);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes all listeners for this object
|
||
|
|
*/
|
||
|
|
purgeListeners : function(){
|
||
|
|
for(var evt in this.events){
|
||
|
|
if(typeof this.events[evt] == "object"){
|
||
|
|
this.events[evt].clearListeners();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Relays selected events from the specified Observable as if the events were fired by <tt><b>this</b></tt>.
|
||
|
|
* @param {Object} o The Observable whose events this object is to relay.
|
||
|
|
* @param {Array} events Array of event names to relay.
|
||
|
|
*/
|
||
|
|
relayEvents : function(o, events){
|
||
|
|
var createHandler = function(ename){
|
||
|
|
return function(){
|
||
|
|
return this.fireEvent.apply(this, Ext.combine(ename, Array.prototype.slice.call(arguments, 0)));
|
||
|
|
};
|
||
|
|
};
|
||
|
|
for(var i = 0, len = events.length; i < len; i++){
|
||
|
|
var ename = events[i];
|
||
|
|
if(!this.events[ename]){ this.events[ename] = true; };
|
||
|
|
o.on(ename, createHandler(ename), this);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Used to define events on this Observable
|
||
|
|
* @param {Object} object The object with the events defined
|
||
|
|
*/
|
||
|
|
addEvents : function(o){
|
||
|
|
if(!this.events){
|
||
|
|
this.events = {};
|
||
|
|
}
|
||
|
|
if(typeof o == 'string'){
|
||
|
|
for(var i = 0, a = arguments, v; v = a[i]; i++){
|
||
|
|
if(!this.events[a[i]]){
|
||
|
|
this.events[a[i]] = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}else{
|
||
|
|
Ext.applyIf(this.events, o);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks to see if this object has any listeners for a specified event
|
||
|
|
* @param {String} eventName The name of the event to check for
|
||
|
|
* @return {Boolean} True if the event is being listened for, else false
|
||
|
|
*/
|
||
|
|
hasListener : function(eventName){
|
||
|
|
var e = this.events[eventName];
|
||
|
|
return typeof e == "object" && e.listeners.length > 0;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Suspend the firing of all events. (see {@link #resumeEvents})
|
||
|
|
*/
|
||
|
|
suspendEvents : function(){
|
||
|
|
this.eventsSuspended = true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Resume firing events. (see {@link #suspendEvents})
|
||
|
|
*/
|
||
|
|
resumeEvents : function(){
|
||
|
|
this.eventsSuspended = false;
|
||
|
|
},
|
||
|
|
|
||
|
|
// these are considered experimental
|
||
|
|
// allows for easier interceptor and sequences, including cancelling and overwriting the return value of the call
|
||
|
|
// private
|
||
|
|
getMethodEvent : function(method){
|
||
|
|
if(!this.methodEvents){
|
||
|
|
this.methodEvents = {};
|
||
|
|
}
|
||
|
|
var e = this.methodEvents[method];
|
||
|
|
if(!e){
|
||
|
|
e = {};
|
||
|
|
this.methodEvents[method] = e;
|
||
|
|
|
||
|
|
e.originalFn = this[method];
|
||
|
|
e.methodName = method;
|
||
|
|
e.before = [];
|
||
|
|
e.after = [];
|
||
|
|
|
||
|
|
|
||
|
|
var returnValue, v, cancel;
|
||
|
|
var obj = this;
|
||
|
|
|
||
|
|
var makeCall = function(fn, scope, args){
|
||
|
|
if((v = fn.apply(scope || obj, args)) !== undefined){
|
||
|
|
if(typeof v === 'object'){
|
||
|
|
if(v.returnValue !== undefined){
|
||
|
|
returnValue = v.returnValue;
|
||
|
|
}else{
|
||
|
|
returnValue = v;
|
||
|
|
}
|
||
|
|
if(v.cancel === true){
|
||
|
|
cancel = true;
|
||
|
|
}
|
||
|
|
}else if(v === false){
|
||
|
|
cancel = true;
|
||
|
|
}else {
|
||
|
|
returnValue = v;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
this[method] = function(){
|
||
|
|
returnValue = v = undefined; cancel = false;
|
||
|
|
var args = Array.prototype.slice.call(arguments, 0);
|
||
|
|
for(var i = 0, len = e.before.length; i < len; i++){
|
||
|
|
makeCall(e.before[i].fn, e.before[i].scope, args);
|
||
|
|
if(cancel){
|
||
|
|
return returnValue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if((v = e.originalFn.apply(obj, args)) !== undefined){
|
||
|
|
returnValue = v;
|
||
|
|
}
|
||
|
|
|
||
|
|
for(var i = 0, len = e.after.length; i < len; i++){
|
||
|
|
makeCall(e.after[i].fn, e.after[i].scope, args);
|
||
|
|
if(cancel){
|
||
|
|
return returnValue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return returnValue;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
return e;
|
||
|
|
},
|
||
|
|
|
||
|
|
// adds an "interceptor" called before the original method
|
||
|
|
beforeMethod : function(method, fn, scope){
|
||
|
|
var e = this.getMethodEvent(method);
|
||
|
|
e.before.push({fn: fn, scope: scope});
|
||
|
|
},
|
||
|
|
|
||
|
|
// adds a "sequence" called after the original method
|
||
|
|
afterMethod : function(method, fn, scope){
|
||
|
|
var e = this.getMethodEvent(method);
|
||
|
|
e.after.push({fn: fn, scope: scope});
|
||
|
|
},
|
||
|
|
|
||
|
|
removeMethodListener : function(method, fn, scope){
|
||
|
|
var e = this.getMethodEvent(method);
|
||
|
|
for(var i = 0, len = e.before.length; i < len; i++){
|
||
|
|
if(e.before[i].fn == fn && e.before[i].scope == scope){
|
||
|
|
e.before.splice(i, 1);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for(var i = 0, len = e.after.length; i < len; i++){
|
||
|
|
if(e.after[i].fn == fn && e.after[i].scope == scope){
|
||
|
|
e.after.splice(i, 1);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
/**
|
||
|
|
* Appends an event handler to this element (shorthand for addListener)
|
||
|
|
* @param {String} eventName The type of event to listen for
|
||
|
|
* @param {Function} handler The method the event invokes
|
||
|
|
* @param {Object} scope (optional) The scope in which to execute the handler
|
||
|
|
* function. The handler function's "this" context.
|
||
|
|
* @param {Object} options (optional)
|
||
|
|
* @method
|
||
|
|
*/
|
||
|
|
Ext.util.Observable.prototype.on = Ext.util.Observable.prototype.addListener;
|
||
|
|
/**
|
||
|
|
* Removes a listener (shorthand for removeListener)
|
||
|
|
* @param {String} eventName The type of event to listen for
|
||
|
|
* @param {Function} handler The handler to remove
|
||
|
|
* @param {Object} scope (optional) The scope (this object) for the handler
|
||
|
|
* @method
|
||
|
|
*/
|
||
|
|
Ext.util.Observable.prototype.un = Ext.util.Observable.prototype.removeListener;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Starts capture on the specified Observable. All events will be passed
|
||
|
|
* to the supplied function with the event name + standard signature of the event
|
||
|
|
* <b>before</b> the event is fired. If the supplied function returns false,
|
||
|
|
* the event will not fire.
|
||
|
|
* @param {Observable} o The Observable to capture
|
||
|
|
* @param {Function} fn The function to call
|
||
|
|
* @param {Object} scope (optional) The scope (this object) for the fn
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
Ext.util.Observable.capture = function(o, fn, scope){
|
||
|
|
o.fireEvent = o.fireEvent.createInterceptor(fn, scope);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes <b>all</b> added captures from the Observable.
|
||
|
|
* @param {Observable} o The Observable to release
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
Ext.util.Observable.releaseCapture = function(o){
|
||
|
|
o.fireEvent = Ext.util.Observable.prototype.fireEvent;
|
||
|
|
};
|
||
|
|
|
||
|
|
(function(){
|
||
|
|
|
||
|
|
var createBuffered = function(h, o, scope){
|
||
|
|
var task = new Ext.util.DelayedTask();
|
||
|
|
return function(){
|
||
|
|
task.delay(o.buffer, h, scope, Array.prototype.slice.call(arguments, 0));
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
var createSingle = function(h, e, fn, scope){
|
||
|
|
return function(){
|
||
|
|
e.removeListener(fn, scope);
|
||
|
|
return h.apply(scope, arguments);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
var createDelayed = function(h, o, scope){
|
||
|
|
return function(){
|
||
|
|
var args = Array.prototype.slice.call(arguments, 0);
|
||
|
|
setTimeout(function(){
|
||
|
|
h.apply(scope, args);
|
||
|
|
}, o.delay || 10);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
Ext.util.Event = function(obj, name){
|
||
|
|
this.name = name;
|
||
|
|
this.obj = obj;
|
||
|
|
this.listeners = [];
|
||
|
|
};
|
||
|
|
|
||
|
|
Ext.util.Event.prototype = {
|
||
|
|
addListener : function(fn, scope, options){
|
||
|
|
scope = scope || this.obj;
|
||
|
|
if(!this.isListening(fn, scope)){
|
||
|
|
var l = this.createListener(fn, scope, options);
|
||
|
|
if(!this.firing){
|
||
|
|
this.listeners.push(l);
|
||
|
|
}else{ // if we are currently firing this event, don't disturb the listener loop
|
||
|
|
this.listeners = this.listeners.slice(0);
|
||
|
|
this.listeners.push(l);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
createListener : function(fn, scope, o){
|
||
|
|
o = o || {};
|
||
|
|
scope = scope || this.obj;
|
||
|
|
var l = {fn: fn, scope: scope, options: o};
|
||
|
|
var h = fn;
|
||
|
|
if(o.delay){
|
||
|
|
h = createDelayed(h, o, scope);
|
||
|
|
}
|
||
|
|
if(o.single){
|
||
|
|
h = createSingle(h, this, fn, scope);
|
||
|
|
}
|
||
|
|
if(o.buffer){
|
||
|
|
h = createBuffered(h, o, scope);
|
||
|
|
}
|
||
|
|
l.fireFn = h;
|
||
|
|
return l;
|
||
|
|
},
|
||
|
|
|
||
|
|
findListener : function(fn, scope){
|
||
|
|
scope = scope || this.obj;
|
||
|
|
var ls = this.listeners;
|
||
|
|
for(var i = 0, len = ls.length; i < len; i++){
|
||
|
|
var l = ls[i];
|
||
|
|
if(l.fn == fn && l.scope == scope){
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
},
|
||
|
|
|
||
|
|
isListening : function(fn, scope){
|
||
|
|
return this.findListener(fn, scope) != -1;
|
||
|
|
},
|
||
|
|
|
||
|
|
removeListener : function(fn, scope){
|
||
|
|
var index;
|
||
|
|
if((index = this.findListener(fn, scope)) != -1){
|
||
|
|
if(!this.firing){
|
||
|
|
this.listeners.splice(index, 1);
|
||
|
|
}else{
|
||
|
|
this.listeners = this.listeners.slice(0);
|
||
|
|
this.listeners.splice(index, 1);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
},
|
||
|
|
|
||
|
|
clearListeners : function(){
|
||
|
|
this.listeners = [];
|
||
|
|
},
|
||
|
|
|
||
|
|
fire : function(){
|
||
|
|
var ls = this.listeners, scope, len = ls.length;
|
||
|
|
if(len > 0){
|
||
|
|
this.firing = true;
|
||
|
|
var args = Array.prototype.slice.call(arguments, 0);
|
||
|
|
for(var i = 0; i < len; i++){
|
||
|
|
var l = ls[i];
|
||
|
|
if(l.fireFn.apply(l.scope||this.obj||window, arguments) === false){
|
||
|
|
this.firing = false;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.firing = false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
})();
|