Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo._base.event"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo._base.event"] = true;

dojo.provide("dojo._base.event");

dojo.require("dojo._base.connect");

// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA

(function(){

	// DOM event listener machinery

	var del = dojo._event_listener = {

		add: function(/*DOMNode*/node, /*String*/name, /*Function*/fp){

			if(!node){return;}

			name = del._normalizeEventName(name);

			fp = del._fixCallback(name, fp);

			var oname = name;

			if((!dojo.isIE)&&((name == "mouseenter")||(name == "mouseleave"))){

				var oname = name;

				var ofp = fp;

				name = (name == "mouseenter") ? "mouseover" : "mouseout";

				fp = function(e){

					// thanks ben!

					var id = dojo.isDescendant(e.relatedTarget, node);

					if(id == false){

						// e.type = oname; // FIXME: doesn't take?

						return ofp.call(this, e);

					}

				}

			}

			node.addEventListener(name, fp, false);

			return fp; /*Handle*/

		},

		remove: function(/*DOMNode*/node, /*String*/event, /*Handle*/handle){

			// summary:

			//		clobbers the listener from the node

			// node:

			//		DOM node to attach the event to

			// event:

			//		the name of the handler to remove the function from

			// handle:

			//		the handle returned from add

			(node)&&(node.removeEventListener(del._normalizeEventName(event), handle, false));

		},

		_normalizeEventName: function(/*String*/name){

			// Generally, name should be lower case, unless it is special

			// somehow (e.g. a Mozilla DOM event).

			// Remove 'on'.

			return (name.slice(0,2)=="on" ? name.slice(2) : name);

		},

		_fixCallback: function(/*String*/name, fp){

			// By default, we only invoke _fixEvent for 'keypress'

			// If code is added to _fixEvent for other events, we have

			// to revisit this optimization.

			// This also applies to _fixEvent overrides for Safari and Opera

			// below.

			return (name!="keypress" ? fp : function(e){ return fp.call(this, del._fixEvent(e, this)); });

		},

		_fixEvent: function(evt, sender){

			// _fixCallback only attaches us to keypress.

			// Switch on evt.type anyway because we might

			// be called directly from dojo.fixEvent.

			switch(evt.type){

				case "keypress":

					del._setKeyChar(evt);

					break;

			}

			return evt;

		},

		_setKeyChar: function(evt){

			evt.keyChar = (evt.charCode ? String.fromCharCode(evt.charCode) : '');

		}

	};

	// DOM events

	dojo.fixEvent = function(/*Event*/evt, /*DOMNode*/sender){

		// summary:

		//		normalizes properties on the event object including event

		//		bubbling methods, keystroke normalization, and x/y positions

		// evt: Event

		//		native event object

		// sender: DOMNode

		//		node to treat as "currentTarget"

		return del._fixEvent(evt, sender);

	}

	dojo.stopEvent = function(/*Event*/evt){

		// summary:

		//		prevents propagation and clobbers the default action of the

		//		passed event

		// evt: Event

		//		The event object. If omitted, window.event is used on IE.

		evt.preventDefault();

		evt.stopPropagation();

		// NOTE: below, this method is overridden for IE

	}

	// the default listener to use on dontFix nodes, overriden for IE

	var node_listener = dojo._listener;

	// Unify connect and event listeners

	dojo._connect = function(obj, event, context, method, dontFix){

		// FIXME: need a more strict test

		var isNode = obj && (obj.nodeType||obj.attachEvent||obj.addEventListener);

		// choose one of three listener options: raw (connect.js), DOM event on a Node, custom event on a Node

		// we need the third option to provide leak prevention on broken browsers (IE)

		var lid = !isNode ? 0 : (!dontFix ? 1 : 2), l = [dojo._listener, del, node_listener][lid];

		// create a listener

		var h = l.add(obj, event, dojo.hitch(context, method));

		// formerly, the disconnect package contained "l" directly, but if client code

		// leaks the disconnect package (by connecting it to a node), referencing "l"

		// compounds the problem.

		// instead we return a listener id, which requires custom _disconnect below.

		// return disconnect package

		return [ obj, event, h, lid ];

	}

	dojo._disconnect = function(obj, event, handle, listener){

		([dojo._listener, del, node_listener][listener]).remove(obj, event, handle);

	}

	// Constants

	// Public: client code should test

	// keyCode against these named constants, as the

	// actual codes can vary by browser.

	dojo.keys = {

		BACKSPACE: 8,

		TAB: 9,

		CLEAR: 12,

		ENTER: 13,

		SHIFT: 16,

		CTRL: 17,

		ALT: 18,

		PAUSE: 19,

		CAPS_LOCK: 20,

		ESCAPE: 27,

		SPACE: 32,

		PAGE_UP: 33,

		PAGE_DOWN: 34,

		END: 35,

		HOME: 36,

		LEFT_ARROW: 37,

		UP_ARROW: 38,

		RIGHT_ARROW: 39,

		DOWN_ARROW: 40,

		INSERT: 45,

		DELETE: 46,

		HELP: 47,

		LEFT_WINDOW: 91,

		RIGHT_WINDOW: 92,

		SELECT: 93,

		NUMPAD_0: 96,

		NUMPAD_1: 97,

		NUMPAD_2: 98,

		NUMPAD_3: 99,

		NUMPAD_4: 100,

		NUMPAD_5: 101,

		NUMPAD_6: 102,

		NUMPAD_7: 103,

		NUMPAD_8: 104,

		NUMPAD_9: 105,

		NUMPAD_MULTIPLY: 106,

		NUMPAD_PLUS: 107,

		NUMPAD_ENTER: 108,

		NUMPAD_MINUS: 109,

		NUMPAD_PERIOD: 110,

		NUMPAD_DIVIDE: 111,

		F1: 112,

		F2: 113,

		F3: 114,

		F4: 115,

		F5: 116,

		F6: 117,

		F7: 118,

		F8: 119,

		F9: 120,

		F10: 121,

		F11: 122,

		F12: 123,

		F13: 124,

		F14: 125,

		F15: 126,

		NUM_LOCK: 144,

		SCROLL_LOCK: 145

	};

	// IE event normalization

	if(dojo.isIE){

		var _trySetKeyCode = function(e, code){

			try{

				// squelch errors when keyCode is read-only

				// (e.g. if keyCode is ctrl or shift)

				return (e.keyCode = code);

			}catch(e){

				return 0;

			}

		}

		// by default, use the standard listener

		var iel = dojo._listener;

		// dispatcher tracking property

		if(!djConfig._allow_leaks){

			// custom listener that handles leak protection for DOM events

			node_listener = iel = dojo._ie_listener = {

				// support handler indirection: event handler functions are

				// referenced here. Event dispatchers hold only indices.

				handlers: [],

				// add a listener to an object

				add: function(/*Object*/ source, /*String*/ method, /*Function*/ listener){

					source = source || dojo.global;

					var f = source[method];

					if(!f||!f._listeners){

						var d = dojo._getIeDispatcher();

						// original target function is special

						d.target = f && (ieh.push(f) - 1);

						// dispatcher holds a list of indices into handlers table

						d._listeners = [];

						// redirect source to dispatcher

						f = source[method] = d;

					}

					return f._listeners.push(ieh.push(listener) - 1) ; /*Handle*/

				},

				// remove a listener from an object

				remove: function(/*Object*/ source, /*String*/ method, /*Handle*/ handle){

					var f = (source||dojo.global)[method], l = f&&f._listeners;

					if(f && l && handle--){

						delete ieh[l[handle]];

						delete l[handle];

					}

				}

			};

			// alias used above

			var ieh = iel.handlers;

		}

		dojo.mixin(del, {

			add: function(/*DOMNode*/node, /*String*/event, /*Function*/fp){

				if(!node){return;} // undefined

				event = del._normalizeEventName(event);

				if(event=="onkeypress"){

					// we need to listen to onkeydown to synthesize

					// keypress events that otherwise won't fire

					// on IE

					var kd = node.onkeydown;

					if(!kd||!kd._listeners||!kd._stealthKeydown){

						// we simply ignore this connection when disconnecting

						// because it's side-effects are harmless

						del.add(node, "onkeydown", del._stealthKeyDown);

						// we only want one stealth listener per node

						node.onkeydown._stealthKeydown = true;

					}

				}

				return iel.add(node, event, del._fixCallback(fp));

			},

			remove: function(/*DOMNode*/node, /*String*/event, /*Handle*/handle){

				iel.remove(node, del._normalizeEventName(event), handle);

			},

			_normalizeEventName: function(/*String*/eventName){

				// Generally, eventName should be lower case, unless it is

				// special somehow (e.g. a Mozilla event)

				// ensure 'on'

				return (eventName.slice(0,2)!="on" ? "on"+eventName : eventName);

			},

			_nop: function(){},

			_fixEvent: function(/*Event*/evt, /*DOMNode*/sender){

				// summary:

				//		normalizes properties on the event object including event

				//		bubbling methods, keystroke normalization, and x/y positions

				// evt: native event object

				// sender: node to treat as "currentTarget"

				if(!evt){

					var w = (sender)&&((sender.ownerDocument || sender.document || sender).parentWindow)||window;

					evt = w.event;

				}

				if(!evt){return(evt);}

				evt.target = evt.srcElement;

				evt.currentTarget = (sender || evt.srcElement);

				evt.layerX = evt.offsetX;

				evt.layerY = evt.offsetY;

				// FIXME: scroll position query is duped from dojo.html to

				// avoid dependency on that entire module. Now that HTML is in

				// Base, we should convert back to something similar there.

				var se = evt.srcElement, doc = (se && se.ownerDocument) || document;

				// DO NOT replace the following to use dojo.body(), in IE, document.documentElement should be used

				// here rather than document.body

				var docBody = ((dojo.isIE<6)||(doc["compatMode"]=="BackCompat")) ? doc.body : doc.documentElement;

				var offset = dojo._getIeDocumentElementOffset();

				evt.pageX = evt.clientX + dojo._fixIeBiDiScrollLeft(docBody.scrollLeft || 0) - offset.x;

				evt.pageY = evt.clientY + (docBody.scrollTop || 0) - offset.y;

				if(evt.type == "mouseover"){

					evt.relatedTarget = evt.fromElement;

				}

				if(evt.type == "mouseout"){

					evt.relatedTarget = evt.toElement;

				}

				evt.stopPropagation = del._stopPropagation;

				evt.preventDefault = del._preventDefault;

				return del._fixKeys(evt);

			},

			_fixKeys: function(evt){

				switch(evt.type){

					case "keypress":

						var c = ("charCode" in evt ? evt.charCode : evt.keyCode);

						if (c==10){

							// CTRL-ENTER is CTRL-ASCII(10) on IE, but CTRL-ENTER on Mozilla

							c=0;

							evt.keyCode = 13;

						}else if(c==13||c==27){

							c=0; // Mozilla considers ENTER and ESC non-printable

						}else if(c==3){

							c=99; // Mozilla maps CTRL-BREAK to CTRL-c

						}

						// Mozilla sets keyCode to 0 when there is a charCode

						// but that stops the event on IE.

						evt.charCode = c;

						del._setKeyChar(evt);

						break;

				}

				return evt;

			},

			// some ctrl-key combinations (mostly w/punctuation) do not emit a char code in IE

			// we map those virtual key codes to ascii here

			// not valid for all (non-US) keyboards, so maybe we shouldn't bother

			_punctMap: {

				106:42,

				111:47,

				186:59,

				187:43,

				188:44,

				189:45,

				190:46,

				191:47,

				192:96,

				219:91,

				220:92,

				221:93,

				222:39

			},

			_stealthKeyDown: function(evt){

				// IE doesn't fire keypress for most non-printable characters.

				// other browsers do, we simulate it here.

				var kp=evt.currentTarget.onkeypress;

				// only works if kp exists and is a dispatcher

				if(!kp||!kp._listeners)return;

				// munge key/charCode

				var k=evt.keyCode;

				// These are Windows Virtual Key Codes

				// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp

				var unprintable = (k!=13)&&(k!=32)&&(k!=27)&&(k<48||k>90)&&(k<96||k>111)&&(k<186||k>192)&&(k<219||k>222);

				// synthesize keypress for most unprintables and CTRL-keys

				if(unprintable||evt.ctrlKey){

					var c = (unprintable ? 0 : k);

					if(evt.ctrlKey){

						if(k==3 || k==13){

							return; // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively

						}else if(c>95 && c<106){

							c -= 48; // map CTRL-[numpad 0-9] to ASCII

						}else if((!evt.shiftKey)&&(c>=65&&c<=90)){

							c += 32; // map CTRL-[A-Z] to lowercase

						}else{

							c = del._punctMap[c] || c; // map other problematic CTRL combinations to ASCII

						}

					}

					// simulate a keypress event

					var faux = del._synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});

					kp.call(evt.currentTarget, faux);

					evt.cancelBubble = faux.cancelBubble;

					evt.returnValue = faux.returnValue;

					_trySetKeyCode(evt, faux.keyCode);

				}

			},

			// Called in Event scope

			_stopPropagation: function(){

				this.cancelBubble = true;

			},

			_preventDefault: function(){

				// Setting keyCode to 0 is the only way to prevent certain keypresses (namely

				// ctrl-combinations that correspond to menu accelerator keys).

				// Otoh, it prevents upstream listeners from getting this information

				// Try to split the difference here by clobbering keyCode only for ctrl

				// combinations. If you still need to access the key upstream, bubbledKeyCode is

				// provided as a workaround.

				this.bubbledKeyCode = this.keyCode;

				if(this.ctrlKey){_trySetKeyCode(this, 0);}

				this.returnValue = false;

			}

		});

		// override stopEvent for IE

		dojo.stopEvent = function(evt){

			evt = evt || window.event;

			del._stopPropagation.call(evt);

			del._preventDefault.call(evt);

		}

	}

	del._synthesizeEvent = function(evt, props){

			var faux = dojo.mixin({}, evt, props);

			del._setKeyChar(faux);

			// FIXME: would prefer to use dojo.hitch: dojo.hitch(evt, evt.preventDefault);

			// but it throws an error when preventDefault is invoked on Safari

			// does Event.preventDefault not support "apply" on Safari?

			faux.preventDefault = function(){ evt.preventDefault(); };

			faux.stopPropagation = function(){ evt.stopPropagation(); };

			return faux;

	}

	// Opera event normalization

	if(dojo.isOpera){

		dojo.mixin(del, {

			_fixEvent: function(evt, sender){

				switch(evt.type){

					case "keypress":

						var c = evt.which;

						if(c==3){

							c=99; // Mozilla maps CTRL-BREAK to CTRL-c

						}

						// can't trap some keys at all, like INSERT and DELETE

						// there is no differentiating info between DELETE and ".", or INSERT and "-"

						c = ((c<41)&&(!evt.shiftKey) ? 0 : c);

						if((evt.ctrlKey)&&(!evt.shiftKey)&&(c>=65)&&(c<=90)){

							// lowercase CTRL-[A-Z] keys

							c += 32;

						}

						return del._synthesizeEvent(evt, { charCode: c });

				}

				return evt;

			}

		});

	}

	// Safari event normalization

	if(dojo.isSafari){

		dojo.mixin(del, {

			_fixEvent: function(evt, sender){

				switch(evt.type){

					case "keypress":

						var c = evt.charCode, s = evt.shiftKey, k = evt.keyCode;

						// FIXME: This is a hack, suggest we rethink keyboard strategy.

						// Arrow and page keys have 0 "keyCode" in keypress events.on Safari for Windows

						k = k || identifierMap[evt.keyIdentifier] || 0;

						if(evt.keyIdentifier=="Enter"){

							c = 0; // differentiate Enter from CTRL-m (both code 13)

						}else if((evt.ctrlKey)&&(c>0)&&(c<27)){

							c += 96; // map CTRL-[A-Z] codes to ASCII

						} else if (c==dojo.keys.SHIFT_TAB) {

							c = dojo.keys.TAB; // morph SHIFT_TAB into TAB + shiftKey: true

							s = true;

						} else {

							c = (c>=32 && c<63232 ? c : 0); // avoid generating keyChar for non-printables

						}

						return del._synthesizeEvent(evt, {charCode: c, shiftKey: s, keyCode: k});

				}

				return evt;

			}

		});

		dojo.mixin(dojo.keys, {

			SHIFT_TAB: 25,

			UP_ARROW: 63232,

			DOWN_ARROW: 63233,

			LEFT_ARROW: 63234,

			RIGHT_ARROW: 63235,

			F1: 63236,

			F2: 63237,

			F3: 63238,

			F4: 63239,

			F5: 63240,

			F6: 63241,

			F7: 63242,

			F8: 63243,

			F9: 63244,

			F10: 63245,

			F11: 63246,

			F12: 63247,

			PAUSE: 63250,

			DELETE: 63272,

			HOME: 63273,

			END: 63275,

			PAGE_UP: 63276,

			PAGE_DOWN: 63277,

			INSERT: 63302,

			PRINT_SCREEN: 63248,

			SCROLL_LOCK: 63249,

			NUM_LOCK: 63289

		});

		var dk = dojo.keys, identifierMap = { "Up": dk.UP_ARROW, "Down": dk.DOWN_ARROW, "Left": dk.LEFT_ARROW, "Right": dk.RIGHT_ARROW, "PageUp": dk.PAGE_UP, "PageDown": dk.PAGE_DOWN };

	}

})();

if(dojo.isIE){

	// keep this out of the closure

	// closing over 'iel' or 'ieh' b0rks leak prevention

	// ls[i] is an index into the master handler array

	dojo._getIeDispatcher = function(){

		return function(){

			var ap=Array.prototype, h=dojo._ie_listener.handlers, c=arguments.callee, ls=c._listeners, t=h[c.target];

			// return value comes from original target function

			var r = t && t.apply(this, arguments);

			// invoke listeners after target function

			for(var i in ls){

				if(!(i in ap)){

					h[ls[i]].apply(this, arguments);

				}

			}

			return r;

		}

	}

	// keep this out of the closure to reduce RAM allocation

	dojo._event_listener._fixCallback = function(fp){

		var f = dojo._event_listener._fixEvent;

		return function(e){ return fp.call(this, f(e, this)); };

	}

}

}