summaryrefslogtreecommitdiff
path: root/lib/dojo/on.js.uncompressed.js
diff options
context:
space:
mode:
Diffstat (limited to 'lib/dojo/on.js.uncompressed.js')
-rw-r--r--lib/dojo/on.js.uncompressed.js514
1 files changed, 514 insertions, 0 deletions
diff --git a/lib/dojo/on.js.uncompressed.js b/lib/dojo/on.js.uncompressed.js
new file mode 100644
index 000000000..cea30aca6
--- /dev/null
+++ b/lib/dojo/on.js.uncompressed.js
@@ -0,0 +1,514 @@
+define("dojo/on", ["./has!dom-addeventlistener?:./aspect", "./_base/kernel", "./has"], function(aspect, dojo, has){
+
+ "use strict";
+ if( 1 ){ // check to make sure we are in a browser, this module should work anywhere
+ var major = window.ScriptEngineMajorVersion;
+ has.add("jscript", major && (major() + ScriptEngineMinorVersion() / 10));
+ has.add("event-orientationchange", has("touch") && !has("android")); // TODO: how do we detect this?
+ has.add("event-stopimmediatepropagation", window.Event && !!window.Event.prototype && !!window.Event.prototype.stopImmediatePropagation);
+ }
+ var on = function(target, type, listener, dontFix){
+ // summary:
+ // A function that provides core event listening functionality. With this function
+ // you can provide a target, event type, and listener to be notified of
+ // future matching events that are fired.
+ // target: Element|Object
+ // This is the target object or DOM element that to receive events from
+ // type: String|Function
+ // This is the name of the event to listen for or an extension event type.
+ // listener: Function
+ // This is the function that should be called when the event fires.
+ // returns: Object
+ // An object with a remove() method that can be used to stop listening for this
+ // event.
+ // description:
+ // To listen for "click" events on a button node, we can do:
+ // | define(["dojo/on"], function(listen){
+ // | on(button, "click", clickHandler);
+ // | ...
+ // Evented JavaScript objects can also have their own events.
+ // | var obj = new Evented;
+ // | on(obj, "foo", fooHandler);
+ // And then we could publish a "foo" event:
+ // | on.emit(obj, "foo", {key: "value"});
+ // We can use extension events as well. For example, you could listen for a tap gesture:
+ // | define(["dojo/on", "dojo/gesture/tap", function(listen, tap){
+ // | on(button, tap, tapHandler);
+ // | ...
+ // which would trigger fooHandler. Note that for a simple object this is equivalent to calling:
+ // | obj.onfoo({key:"value"});
+ // If you use on.emit on a DOM node, it will use native event dispatching when possible.
+
+ if(typeof target.on == "function" && typeof type != "function"){
+ // delegate to the target's on() method, so it can handle it's own listening if it wants
+ return target.on(type, listener);
+ }
+ // delegate to main listener code
+ return on.parse(target, type, listener, addListener, dontFix, this);
+ };
+ on.pausable = function(target, type, listener, dontFix){
+ // summary:
+ // This function acts the same as on(), but with pausable functionality. The
+ // returned signal object has pause() and resume() functions. Calling the
+ // pause() method will cause the listener to not be called for future events. Calling the
+ // resume() method will cause the listener to again be called for future events.
+ var paused;
+ var signal = on(target, type, function(){
+ if(!paused){
+ return listener.apply(this, arguments);
+ }
+ }, dontFix);
+ signal.pause = function(){
+ paused = true;
+ };
+ signal.resume = function(){
+ paused = false;
+ };
+ return signal;
+ };
+ on.once = function(target, type, listener, dontFix){
+ // summary:
+ // This function acts the same as on(), but will only call the listener once. The
+ // listener will be called for the first
+ // event that takes place and then listener will automatically be removed.
+ var signal = on(target, type, function(){
+ // remove this listener
+ signal.remove();
+ // proceed to call the listener
+ return listener.apply(this, arguments);
+ });
+ return signal;
+ };
+ on.parse = function(target, type, listener, addListener, dontFix, matchesTarget){
+ if(type.call){
+ // event handler function
+ // on(node, touch.press, touchListener);
+ return type.call(matchesTarget, target, listener);
+ }
+
+ if(type.indexOf(",") > -1){
+ // we allow comma delimited event names, so you can register for multiple events at once
+ var events = type.split(/\s*,\s*/);
+ var handles = [];
+ var i = 0;
+ var eventName;
+ while(eventName = events[i++]){
+ handles.push(addListener(target, eventName, listener, dontFix, matchesTarget));
+ }
+ handles.remove = function(){
+ for(var i = 0; i < handles.length; i++){
+ handles[i].remove();
+ }
+ };
+ return handles;
+ }
+ return addListener(target, type, listener, dontFix, matchesTarget);
+ };
+ var touchEvents = /^touch/;
+ function addListener(target, type, listener, dontFix, matchesTarget){
+ // event delegation:
+ var selector = type.match(/(.*):(.*)/);
+ // if we have a selector:event, the last one is interpreted as an event, and we use event delegation
+ if(selector){
+ type = selector[2];
+ selector = selector[1];
+ // create the extension event for selectors and directly call it
+ return on.selector(selector, type).call(matchesTarget, target, listener);
+ }
+ // test to see if it a touch event right now, so we don't have to do it every time it fires
+ if(has("touch")){
+ if(touchEvents.test(type)){
+ // touch event, fix it
+ listener = fixTouchListener(listener);
+ }
+ if(!has("event-orientationchange") && (type == "orientationchange")){
+ //"orientationchange" not supported <= Android 2.1,
+ //but works through "resize" on window
+ type = "resize";
+ target = window;
+ listener = fixTouchListener(listener);
+ }
+ }
+ if(addStopImmediate){
+ // add stopImmediatePropagation if it doesn't exist
+ listener = addStopImmediate(listener);
+ }
+ // normal path, the target is |this|
+ if(target.addEventListener){
+ // the target has addEventListener, which should be used if available (might or might not be a node, non-nodes can implement this method as well)
+ // check for capture conversions
+ var capture = type in captures,
+ adjustedType = capture ? captures[type] : type;
+ target.addEventListener(adjustedType, listener, capture);
+ // create and return the signal
+ return {
+ remove: function(){
+ target.removeEventListener(adjustedType, listener, capture);
+ }
+ };
+ }
+ type = "on" + type;
+ if(fixAttach && target.attachEvent){
+ return fixAttach(target, type, listener);
+ }
+ throw new Error("Target must be an event emitter");
+ }
+
+ on.selector = function(selector, eventType, children){
+ // summary:
+ // Creates a new extension event with event delegation. This is based on
+ // the provided event type (can be extension event) that
+ // only calls the listener when the CSS selector matches the target of the event.
+ //
+ // The application must require() an appropriate level of dojo/query to handle the selector.
+ // selector:
+ // The CSS selector to use for filter events and determine the |this| of the event listener.
+ // eventType:
+ // The event to listen for
+ // children:
+ // Indicates if children elements of the selector should be allowed. This defaults to
+ // true
+ // example:
+ // | require(["dojo/on", "dojo/mouse", "dojo/query!css2"], function(listen, mouse){
+ // | on(node, on.selector(".my-class", mouse.enter), handlerForMyHover);
+ return function(target, listener){
+ // if the selector is function, use it to select the node, otherwise use the matches method
+ var matchesTarget = typeof selector == "function" ? {matches: selector} : this,
+ bubble = eventType.bubble;
+ function select(eventTarget){
+ // see if we have a valid matchesTarget or default to dojo.query
+ matchesTarget = matchesTarget && matchesTarget.matches ? matchesTarget : dojo.query;
+ // there is a selector, so make sure it matches
+ while(!matchesTarget.matches(eventTarget, selector, target)){
+ if(eventTarget == target || children === false || !(eventTarget = eventTarget.parentNode) || eventTarget.nodeType != 1){ // intentional assignment
+ return;
+ }
+ }
+ return eventTarget;
+ }
+ if(bubble){
+ // the event type doesn't naturally bubble, but has a bubbling form, use that, and give it the selector so it can perform the select itself
+ return on(target, bubble(select), listener);
+ }
+ // standard event delegation
+ return on(target, eventType, function(event){
+ // call select to see if we match
+ var eventTarget = select(event.target);
+ // if it matches we call the listener
+ return eventTarget && listener.call(eventTarget, event);
+ });
+ };
+ };
+
+ function syntheticPreventDefault(){
+ this.cancelable = false;
+ }
+ function syntheticStopPropagation(){
+ this.bubbles = false;
+ }
+ var slice = [].slice,
+ syntheticDispatch = on.emit = function(target, type, event){
+ // summary:
+ // Fires an event on the target object.
+ // target:
+ // The target object to fire the event on. This can be a DOM element or a plain
+ // JS object. If the target is a DOM element, native event emiting mechanisms
+ // are used when possible.
+ // type:
+ // The event type name. You can emulate standard native events like "click" and
+ // "mouseover" or create custom events like "open" or "finish".
+ // event:
+ // An object that provides the properties for the event. See https://developer.mozilla.org/en/DOM/event.initEvent
+ // for some of the properties. These properties are copied to the event object.
+ // Of particular importance are the cancelable and bubbles properties. The
+ // cancelable property indicates whether or not the event has a default action
+ // that can be cancelled. The event is cancelled by calling preventDefault() on
+ // the event object. The bubbles property indicates whether or not the
+ // event will bubble up the DOM tree. If bubbles is true, the event will be called
+ // on the target and then each parent successively until the top of the tree
+ // is reached or stopPropagation() is called. Both bubbles and cancelable
+ // default to false.
+ // returns:
+ // If the event is cancelable and the event is not cancelled,
+ // emit will return true. If the event is cancelable and the event is cancelled,
+ // emit will return false.
+ // details:
+ // Note that this is designed to emit events for listeners registered through
+ // dojo/on. It should actually work with any event listener except those
+ // added through IE's attachEvent (IE8 and below's non-W3C event emiting
+ // doesn't support custom event types). It should work with all events registered
+ // through dojo/on. Also note that the emit method does do any default
+ // action, it only returns a value to indicate if the default action should take
+ // place. For example, emiting a keypress event would not cause a character
+ // to appear in a textbox.
+ // example:
+ // To fire our own click event
+ // | on.emit(dojo.byId("button"), "click", {
+ // | cancelable: true,
+ // | bubbles: true,
+ // | screenX: 33,
+ // | screenY: 44
+ // | });
+ // We can also fire our own custom events:
+ // | on.emit(dojo.byId("slider"), "slide", {
+ // | cancelable: true,
+ // | bubbles: true,
+ // | direction: "left-to-right"
+ // | });
+ var args = slice.call(arguments, 2);
+ var method = "on" + type;
+ if("parentNode" in target){
+ // node (or node-like), create event controller methods
+ var newEvent = args[0] = {};
+ for(var i in event){
+ newEvent[i] = event[i];
+ }
+ newEvent.preventDefault = syntheticPreventDefault;
+ newEvent.stopPropagation = syntheticStopPropagation;
+ newEvent.target = target;
+ newEvent.type = type;
+ event = newEvent;
+ }
+ do{
+ // call any node which has a handler (note that ideally we would try/catch to simulate normal event propagation but that causes too much pain for debugging)
+ target[method] && target[method].apply(target, args);
+ // and then continue up the parent node chain if it is still bubbling (if started as bubbles and stopPropagation hasn't been called)
+ }while(event && event.bubbles && (target = target.parentNode));
+ return event && event.cancelable && event; // if it is still true (was cancelable and was cancelled), return the event to indicate default action should happen
+ };
+ var captures = {};
+ if(!has("event-stopimmediatepropagation")){
+ var stopImmediatePropagation =function(){
+ this.immediatelyStopped = true;
+ this.modified = true; // mark it as modified so the event will be cached in IE
+ };
+ var addStopImmediate = function(listener){
+ return function(event){
+ if(!event.immediatelyStopped){// check to make sure it hasn't been stopped immediately
+ event.stopImmediatePropagation = stopImmediatePropagation;
+ return listener.apply(this, arguments);
+ }
+ };
+ }
+ }
+ if(has("dom-addeventlistener")){
+ // normalize focusin and focusout
+ captures = {
+ focusin: "focus",
+ focusout: "blur"
+ };
+
+ // emiter that works with native event handling
+ on.emit = function(target, type, event){
+ if(target.dispatchEvent && document.createEvent){
+ // use the native event emiting mechanism if it is available on the target object
+ // create a generic event
+ // we could create branch into the different types of event constructors, but
+ // that would be a lot of extra code, with little benefit that I can see, seems
+ // best to use the generic constructor and copy properties over, making it
+ // easy to have events look like the ones created with specific initializers
+ var nativeEvent = target.ownerDocument.createEvent("HTMLEvents");
+ nativeEvent.initEvent(type, !!event.bubbles, !!event.cancelable);
+ // and copy all our properties over
+ for(var i in event){
+ var value = event[i];
+ if(!(i in nativeEvent)){
+ nativeEvent[i] = event[i];
+ }
+ }
+ return target.dispatchEvent(nativeEvent) && nativeEvent;
+ }
+ return syntheticDispatch.apply(on, arguments); // emit for a non-node
+ };
+ }else{
+ // no addEventListener, basically old IE event normalization
+ on._fixEvent = function(evt, 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;}
+ if(lastEvent && evt.type == lastEvent.type){
+ // should be same event, reuse event object (so it can be augmented)
+ evt = lastEvent;
+ }
+ if(!evt.target){ // check to see if it has been fixed yet
+ evt.target = evt.srcElement;
+ evt.currentTarget = (sender || evt.srcElement);
+ if(evt.type == "mouseover"){
+ evt.relatedTarget = evt.fromElement;
+ }
+ if(evt.type == "mouseout"){
+ evt.relatedTarget = evt.toElement;
+ }
+ if(!evt.stopPropagation){
+ evt.stopPropagation = stopPropagation;
+ evt.preventDefault = preventDefault;
+ }
+ 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;
+ _setKeyChar(evt);
+ break;
+ }
+ }
+ return evt;
+ };
+ var lastEvent, IESignal = function(handle){
+ this.handle = handle;
+ };
+ IESignal.prototype.remove = function(){
+ delete _dojoIEListeners_[this.handle];
+ };
+ var fixListener = function(listener){
+ // this is a minimal function for closing on the previous listener with as few as variables as possible
+ return function(evt){
+ evt = on._fixEvent(evt, this);
+ var result = listener.call(this, evt);
+ if(evt.modified){
+ // cache the last event and reuse it if we can
+ if(!lastEvent){
+ setTimeout(function(){
+ lastEvent = null;
+ });
+ }
+ lastEvent = evt;
+ }
+ return result;
+ };
+ };
+ var fixAttach = function(target, type, listener){
+ listener = fixListener(listener);
+ if(((target.ownerDocument ? target.ownerDocument.parentWindow : target.parentWindow || target.window || window) != top ||
+ has("jscript") < 5.8) &&
+ !has("config-_allow_leaks")){
+ // IE will leak memory on certain handlers in frames (IE8 and earlier) and in unattached DOM nodes for JScript 5.7 and below.
+ // Here we use global redirection to solve the memory leaks
+ if(typeof _dojoIEListeners_ == "undefined"){
+ _dojoIEListeners_ = [];
+ }
+ var emiter = target[type];
+ if(!emiter || !emiter.listeners){
+ var oldListener = emiter;
+ emiter = Function('event', 'var callee = arguments.callee; for(var i = 0; i<callee.listeners.length; i++){var listener = _dojoIEListeners_[callee.listeners[i]]; if(listener){listener.call(this,event);}}');
+ emiter.listeners = [];
+ target[type] = emiter;
+ emiter.global = this;
+ if(oldListener){
+ emiter.listeners.push(_dojoIEListeners_.push(oldListener) - 1);
+ }
+ }
+ var handle;
+ emiter.listeners.push(handle = (emiter.global._dojoIEListeners_.push(listener) - 1));
+ return new IESignal(handle);
+ }
+ return aspect.after(target, type, listener, true);
+ };
+
+ var _setKeyChar = function(evt){
+ evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
+ evt.charOrCode = evt.keyChar || evt.keyCode;
+ };
+ // Called in Event scope
+ var stopPropagation = function(){
+ this.cancelBubble = true;
+ };
+ var preventDefault = on._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){
+ try{
+ // squelch errors when keyCode is read-only
+ // (e.g. if keyCode is ctrl or shift)
+ this.keyCode = 0;
+ }catch(e){
+ }
+ }
+ this.defaultPrevented = true;
+ this.returnValue = false;
+ };
+ }
+ if(has("touch")){
+ var Event = function(){};
+ var windowOrientation = window.orientation;
+ var fixTouchListener = function(listener){
+ return function(originalEvent){
+ //Event normalization(for ontouchxxx and resize):
+ //1.incorrect e.pageX|pageY in iOS
+ //2.there are no "e.rotation", "e.scale" and "onorientationchange" in Andriod
+ //3.More TBD e.g. force | screenX | screenX | clientX | clientY | radiusX | radiusY
+
+ // see if it has already been corrected
+ var event = originalEvent.corrected;
+ if(!event){
+ var type = originalEvent.type;
+ try{
+ delete originalEvent.type; // on some JS engines (android), deleting properties make them mutable
+ }catch(e){}
+ if(originalEvent.type){
+ // deleting properties doesn't work (older iOS), have to use delegation
+ Event.prototype = originalEvent;
+ var event = new Event;
+ // have to delegate methods to make them work
+ event.preventDefault = function(){
+ originalEvent.preventDefault();
+ };
+ event.stopPropagation = function(){
+ originalEvent.stopPropagation();
+ };
+ }else{
+ // deletion worked, use property as is
+ event = originalEvent;
+ event.type = type;
+ }
+ originalEvent.corrected = event;
+ if(type == 'resize'){
+ if(windowOrientation == window.orientation){
+ return null;//double tap causes an unexpected 'resize' in Andriod
+ }
+ windowOrientation = window.orientation;
+ event.type = "orientationchange";
+ return listener.call(this, event);
+ }
+ // We use the original event and augment, rather than doing an expensive mixin operation
+ if(!("rotation" in event)){ // test to see if it has rotation
+ event.rotation = 0;
+ event.scale = 1;
+ }
+ //use event.changedTouches[0].pageX|pageY|screenX|screenY|clientX|clientY|target
+ var firstChangeTouch = event.changedTouches[0];
+ for(var i in firstChangeTouch){ // use for-in, we don't need to have dependency on dojo/_base/lang here
+ delete event[i]; // delete it first to make it mutable
+ event[i] = firstChangeTouch[i];
+ }
+ }
+ return listener.call(this, event);
+ };
+ };
+ }
+ return on;
+});
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-30 23:51:07 +0000