525 lines
17 KiB
JavaScript
525 lines
17 KiB
JavaScript
/**
|
|
* $Id: eventmanager.js 397 2008-04-22 20:17:57Z wingedfox $
|
|
* $HeadURL: https://svn.debugger.ru/repos/jslibs/BrowserExtensions/tags/BrowserExtensions.018/eventmanager.js $
|
|
*
|
|
* EventManager (EM shorthand) is the class, written to manage event attach/detach/register and so on
|
|
*
|
|
* @modified $Date: 2008-04-23 00:17:57 +0400 (Срд, 23 Апр 2008) $
|
|
* @version $Rev: 397 $
|
|
* @license LGPL 2.1 or later
|
|
* @author Ilya Lebedev <ilya@lebedev.net>
|
|
* @depends helpers.js
|
|
*
|
|
* @class
|
|
* @constructor EventManager
|
|
*/
|
|
var EM = new function () {
|
|
var self = this;
|
|
/**
|
|
* Events pool
|
|
* Element format:
|
|
* { 'node' : {HTMLElement},
|
|
* ['rootEHCaller' : {Function}]
|
|
* 'handler' : {
|
|
* <event_name> : [Function[, Function[, ...]]]
|
|
* [,<event_name> : [Function[, Function[, ...]]]]
|
|
* }
|
|
* }
|
|
*
|
|
* @type Array
|
|
* @scope private
|
|
*/
|
|
var pool = [];
|
|
/**
|
|
* Unique ID counter, used to attach IDs to the objects
|
|
*
|
|
* @type Number
|
|
* @scope private
|
|
*/
|
|
var UID = 0;
|
|
/**
|
|
* List of used keys, applied to different kinds of objects
|
|
*
|
|
* @type Object
|
|
* @scope private
|
|
*/
|
|
var keys = {
|
|
'UEID' : '__eventManagerUniqueElementId'
|
|
// ,'UHID' : '__eventManagerUniqueHandlerId'
|
|
};
|
|
/**************************************************************************
|
|
* PROTECTED METHODS
|
|
***************************************************************************/
|
|
/**
|
|
* Method is being binded to any new event handler, then, when called,
|
|
* does some unification between browser platforms and calls all binded
|
|
* event handlers
|
|
*
|
|
* @param {Event} e event object
|
|
* @scope protected
|
|
*/
|
|
var rootEventHandler = function (e) {
|
|
unifyEvent(e);
|
|
var id = null
|
|
,hid = null
|
|
,el = e.target
|
|
,fe = true
|
|
,res = true;
|
|
|
|
if (!e.currentTarget || !(id = e.currentTarget[keys.UEID]) || !(hid = pool[id].handler[e.type])) return;
|
|
|
|
try {
|
|
for (var i=0, hL=hid.length; i<hL; i++) if (isFunction(hid[i])) res=res&&!(false===hid[i].call(e.currentTarget, e));
|
|
} catch (err) { setTimeout(function(){throw new Error("Event handler for ["+e.type+"] has failed with exception: \""+err.message+"\"");},10) }
|
|
|
|
return res;
|
|
};
|
|
/**
|
|
* Performs events cleanup on page unload
|
|
* It aims to remove leaking closures
|
|
*
|
|
* @param {Event} e window.unload event
|
|
* @scope protected
|
|
*/
|
|
var unloadEventHandler = function (e) {
|
|
for (var i=pool.length-1,pid=null,el=null; i>=0; i--) {
|
|
if (pool[i] && (el=(pid = pool[i]).node)) {
|
|
for (var z in pid.handler) {
|
|
if (!pid.handler.hasOwnProperty(z)) continue;
|
|
try {
|
|
if (el.removeEventListener) {
|
|
el.removeEventListener(z, pid.rootEHCaller?pid.rootEHCaller:rootEventHandler, false);
|
|
} else if (el.detachEvent) {
|
|
el.detachEvent('on'+z, pid.rootEHCaller?pid.rootEHCaller:rootEventHandler);
|
|
}
|
|
} catch (e) {}
|
|
pid.handler[z].length = 0;
|
|
}
|
|
}
|
|
el = pid.node = null;
|
|
}
|
|
if (window.removeEventListener) {
|
|
window.removeEventListener(z, arguments.callee, false);
|
|
} else {
|
|
window.detachEvent('on'+z, arguments.callee);
|
|
}
|
|
};
|
|
/**************************************************************************
|
|
* PRIVATE METHODS
|
|
***************************************************************************/
|
|
/**
|
|
* Makes an event clone, it does not dereference objects in the event properties
|
|
*
|
|
* @param {Event} e event handler
|
|
* @return {Object} cloned event
|
|
* @scope private
|
|
*/
|
|
var unifyEvent = function (e) {
|
|
var i=self.EU.length
|
|
,cur,cur1,k,init
|
|
while (i--) {
|
|
cur = self.EU[i];
|
|
if (cur[0].test(e.type)) {
|
|
k=cur[1].length;
|
|
init = null;
|
|
while (k--) {
|
|
cur1 = cur[1][k];
|
|
if ('init' == cur1[0]) init = cur1[1]
|
|
else if (!e[cur1[0]]) e[cur1[0]] = cur1[1];
|
|
}
|
|
if (init) init.call(e);
|
|
}
|
|
}
|
|
if (!e.target && e.type != 'unload') e.target = e.srcElement;
|
|
return e;
|
|
};
|
|
/**
|
|
* Returns UEID property for the specified element, creates it, if asked
|
|
*
|
|
* @param {Object} el element to find UEID on
|
|
* @param {Boolean} f optional flag to force UEID creation, if not exists
|
|
* @retutn {Number} UEID, if > 0
|
|
* @scope private
|
|
*/
|
|
var getUEID = function (el, f) {
|
|
return el[keys.UEID] || (f && (el[keys.UEID] = ++UID));
|
|
};
|
|
/**************************************************************************
|
|
* PUBLIC METHODS
|
|
***************************************************************************/
|
|
/**
|
|
* Adds the event listener to the queue
|
|
*
|
|
* @param {Object} el element to attach event handler to
|
|
* @param {String} et event name to attach event handler to (without 'on' prefix)
|
|
* @param {Function} h event handler
|
|
* @return {Boolean} success state
|
|
* @scope public
|
|
*/
|
|
self.addEventListener = function (el, et, h) {
|
|
if (!el || !isFunction(h)) return false;
|
|
// if (!el.addEventListener && !el.attachEvent) return false;
|
|
/*
|
|
* unique identifier is used to keep an eye on the element
|
|
*/
|
|
var id = getUEID(el, true)
|
|
,pid = null
|
|
,hid = null;
|
|
|
|
/*
|
|
* prepare pool object, if needed
|
|
*/
|
|
if (!pool[id]) {
|
|
pool[id] = {
|
|
'node' : el
|
|
,'handler' : {}
|
|
}
|
|
};
|
|
pid = pool[id];
|
|
/*
|
|
* prepare handlers storage in the pool object, if needed
|
|
*/
|
|
if (!pid.handler.hasOwnProperty(et)) {
|
|
pid.handler[et] = [];
|
|
/*
|
|
* if we a here, this means that we have not connected to a node yet
|
|
* note, we've already made a check for the required methods existense
|
|
*/
|
|
if (el.addEventListener) {
|
|
el.addEventListener(et, rootEventHandler, false);
|
|
} else if (el.attachEvent) {
|
|
/*
|
|
* this workaround is used to avoid IE's lack of currentTarget property
|
|
*/
|
|
pid.rootEHCaller = function(e) {
|
|
e.currentTarget = pid.node;//pool[id].node;
|
|
var res = rootEventHandler(e);
|
|
e.currentTarget = null;
|
|
return res;
|
|
};
|
|
el.attachEvent('on'+et, pid.rootEHCaller);
|
|
}
|
|
};
|
|
hid = pid.handler[et];
|
|
/*
|
|
* finally, attach handler, if it was not attached before
|
|
*/
|
|
if (hid.indexOf(h)==-1) {
|
|
hid[hid.length] = h;
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
/**
|
|
* Removes the event listener from the queue
|
|
*
|
|
* @param {Object} el element to attach event handler to
|
|
* @param {String} et event name to attach event handler to (without 'on' prefix)
|
|
* @param {Function} h event handler
|
|
* @return {Boolean} success state
|
|
* @scope public
|
|
*/
|
|
self.removeEventListener = function (el,et,h) {
|
|
if (!el || !isFunction(h)) return false;
|
|
var id = getUEID(el)
|
|
,pid = pool[id]
|
|
,eid = null;
|
|
if (pid && (eid = pid.handler[et])) {
|
|
/*
|
|
* we've found an event handler
|
|
*/
|
|
eid.splice(eid.indexOf(h),1);
|
|
if (0 == eid.length) {
|
|
delete pid.handler[et];
|
|
/*
|
|
* remove the actual listener
|
|
*/
|
|
if (el.removeEventListener) {
|
|
el.removeEventListener(et, pid.rootEHCaller?pid.rootEHCaller:rootEventHandler, false);
|
|
} else if (el.detachEvent) {
|
|
el.detachEvent('on'+et, pid.rootEHCaller?pid.rootEHCaller:rootEventHandler);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
/**
|
|
* Dispatch custom events on the specified element
|
|
*
|
|
* @param {Object} e event object itself
|
|
* @return {Boolean} cancelled status
|
|
* @scope public
|
|
*/
|
|
self.dispatchEvent = function (e) {
|
|
var res = rootEventHandler(e);
|
|
return res;
|
|
};
|
|
/**
|
|
* Registers new event handler for any object
|
|
* It's a good idea to register events on the object instances, really
|
|
*
|
|
* @param {Object} o object to register new event on
|
|
* @param {String} n bindable event name
|
|
* @param {Boolean} b optional bubbling allowed flag
|
|
* @param {Function} d optional default action function
|
|
* @return {EMEvent} object, allowing to invoke events
|
|
* @scope public
|
|
* @see EM.EventTarget
|
|
*/
|
|
self.registerEvent = function (o, n, b, d) {
|
|
var id = getUEID(o,true);
|
|
if (!pool[id]) {
|
|
pool[id] = {'node' : o,
|
|
'handler' : []};
|
|
} else {
|
|
pool[id].node = o;
|
|
}
|
|
return new EM.EventTarget(o, n, b, d);
|
|
};
|
|
/**
|
|
* Performs object initialization
|
|
*
|
|
*/
|
|
var __construct = function() {
|
|
/*
|
|
* for IE, to dereference event handlers and remove memory leaks
|
|
*/
|
|
if (window.attachEvent && !window.addEventListener) {
|
|
window.attachEvent('onunload',unloadEventHandler);
|
|
}
|
|
};
|
|
__construct();
|
|
};
|
|
/******************************************************************************
|
|
* STATIC METHODS
|
|
******************************************************************************/
|
|
EM.preventDefaultAction = function(e) {
|
|
e.preventDefault();
|
|
}
|
|
EM.stopPropagationAction = function(e) {
|
|
e.stopPropagation();
|
|
}
|
|
|
|
/******************************************************************************
|
|
* SUPPLEMENTARY CLASSES
|
|
******************************************************************************/
|
|
/**
|
|
* EventTarget base class
|
|
* Used to create self-containing event object
|
|
*
|
|
* @class EM.EventTarget
|
|
* @constructor
|
|
* @param {String} name event name
|
|
* @param {Null, Object} obj event execution context (this), window if null passed
|
|
* @param {Boolean} bubble flag allowing event to bubble across element.parentNode
|
|
* @param {Function} def default action for the event
|
|
*/
|
|
EM.EventTarget = function (obj, name, bubble, def) {
|
|
var self = this;
|
|
|
|
/**
|
|
* Indicates possible bubbling, by default bubbling is not allowed
|
|
*
|
|
* @type Boolean
|
|
* @default false
|
|
* @scope private
|
|
*/
|
|
var canBubble = !!bubble;
|
|
/**
|
|
* Stores function, performing default action for the event
|
|
*
|
|
* @type Function
|
|
* @scope private
|
|
*/
|
|
var defaultAction = isFunction(def)?def:null;
|
|
/**************************************************************************
|
|
* PRIVATE METHODS
|
|
***************************************************************************/
|
|
/**************************************************************************
|
|
* PROTECTED METHODS
|
|
***************************************************************************/
|
|
/**
|
|
* Used to trigger created event on the supplied object or on the 'obj' constructor param
|
|
*
|
|
*
|
|
* @param {Object} el optional element to trigger event on (.target property in the event object)
|
|
* @param {Object} event data
|
|
*/
|
|
self.trigger = function (el, data) {
|
|
if (!(arguments.length-1) && el!=obj) {
|
|
data = el;
|
|
el = null;
|
|
}
|
|
if (!el) el = obj;
|
|
var e = {}
|
|
,res = true
|
|
,undef = true
|
|
,tmp = null
|
|
for (var i in data) {
|
|
if (data.hasOwnProperty(i)) e[i] = data[i];
|
|
}
|
|
|
|
/*
|
|
* set defaults
|
|
*/
|
|
canBubble = !!bubble;
|
|
defaultAction = def;
|
|
|
|
/*
|
|
* start the go
|
|
*/
|
|
do {
|
|
e.preventDefault = preventDefault;
|
|
e.stopPropagation = stopPropagation;
|
|
e.target = el;
|
|
e.currentTarget = el;
|
|
e.type = name;
|
|
tmp = EM.dispatchEvent(e);
|
|
undef &= (isUndefined(tmp))
|
|
res &= !(false===tmp);
|
|
} while ((el = el.parentNode) && canBubble);
|
|
/*
|
|
* try to execute the default action
|
|
*/
|
|
if (isFunction(defaultAction) && res && !undef) {
|
|
defaultAction(e);
|
|
}
|
|
return (defaultAction && res && !undef);
|
|
};
|
|
/**
|
|
* Prevents default event action
|
|
*
|
|
* @scope protected
|
|
*/
|
|
var preventDefault = function () {
|
|
defaultAction = null;
|
|
};
|
|
/**
|
|
* Stops bubbling
|
|
*
|
|
* @scope protected
|
|
*/
|
|
var stopPropagation = function () {
|
|
canBubble = false;
|
|
};
|
|
};
|
|
/**
|
|
* Namespace for event unification routines
|
|
*
|
|
* @type Array
|
|
* @scope protected
|
|
*/
|
|
EM.EU = [
|
|
[/./ , [
|
|
/**
|
|
* Prevents event from calling default event handler
|
|
*
|
|
* @scope protected
|
|
*/
|
|
['preventDefault', function() {
|
|
this.returnValue = false;
|
|
}
|
|
]
|
|
/**
|
|
* Prevents event from futher bubbling
|
|
*
|
|
* @scope protected
|
|
*/
|
|
,['stopPropagation', function() {
|
|
this.cancelBubble = true;
|
|
}
|
|
]
|
|
]]
|
|
,[/^mouse(over|out|down|up)/ , [
|
|
/**
|
|
* Used to detect left or right button pressed.
|
|
* Due to some browser inconsistense, middle button is ignored
|
|
*
|
|
* @return {Number} 1 - left button, 2 - right button
|
|
* @scope protected
|
|
*/
|
|
['getButton', function () {
|
|
return this.button==2?2:1
|
|
}
|
|
]
|
|
,['EM_MB_LEFT', '1']
|
|
,['EM_MB_RIGHT', '2']
|
|
]]
|
|
,[/^key(down|up|press)/ , [
|
|
/**
|
|
* Used to return browser-independend keycode
|
|
*
|
|
* @return {Number} fixed key code
|
|
* @scope protected
|
|
*/
|
|
['getKeyCode', function () {
|
|
switch (this.keyCode) {
|
|
case 189: return 109;
|
|
case 187: return 61;
|
|
case 186: return 59;
|
|
default: return this.keyCode;
|
|
}
|
|
}
|
|
]
|
|
/**
|
|
* Calculates 'repeat' property for the key events
|
|
*
|
|
* @return {Number} 0 means no repeating keystroke detected
|
|
* @scope protected
|
|
*/
|
|
,['getRepeat', function () {
|
|
return arguments.callee.repeat
|
|
}
|
|
]
|
|
,['init', function () {
|
|
var ac = this.getRepeat
|
|
if ('keyup' == this.type) {
|
|
ac.repeat = 0;
|
|
ac.keyCode = 0;
|
|
} else if ('keydown' == this.type) {
|
|
ac.repeat = ac.keyCode==this.keyCode;
|
|
ac.keyCode=this.keyCode;
|
|
}
|
|
}
|
|
]
|
|
]]
|
|
|
|
];
|
|
|
|
/*
|
|
* register core event handler, domload
|
|
* it's called right on the document initialization, before images complete load
|
|
*/
|
|
(function (){
|
|
|
|
var evt = EM.registerEvent(window,'domload')
|
|
,executed = false
|
|
,clearEvents = function() {
|
|
//For IE
|
|
EM.removeEventListener(document, 'propertychange', handlers.ie);
|
|
//For Mozilla
|
|
EM.removeEventListener(document, 'DOMContentLoaded', handlers.mz);
|
|
//For someone else
|
|
EM.removeEventListener(window, 'load', handlers.mz);
|
|
}
|
|
,handlers = { 'ie' : function(e) {
|
|
if (window.event.propertyName == 'activeElement' && !executed) {
|
|
evt.trigger(window);
|
|
clearEvents();
|
|
executed = true;
|
|
}
|
|
}
|
|
,'mz' : function (e) {if(!executed)evt.trigger(window); executed=true;}
|
|
};
|
|
|
|
//For IE
|
|
EM.addEventListener(document, 'propertychange', handlers.ie);
|
|
//For Mozilla
|
|
EM.addEventListener(document,'DOMContentLoaded', handlers.mz);
|
|
//For Safari and Opera
|
|
if(/WebKit|Khtml/i.test(navigator.userAgent)||(window.opera&&parseInt(window.opera.version())<9))(function(){/loaded|complete/.test(document.readyState)?(evt.trigger(window),executed=true):setTimeout(arguments.callee,100)})();
|
|
//For someone else
|
|
EM.addEventListener(window, 'load', handlers.mz);
|
|
})();
|