svn commit: r509273 [14/50] - in /ofbiz/trunk/framework/images/
Locked
svn commit: r509273 [14/50] - in /ofbiz/trunk/framework/images/
 
|
Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/docs.js
------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/docs.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/docs.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/dom.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/dom.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/dom.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/dom.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,560 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.provide("dojo.dom"); + +dojo.dom.ELEMENT_NODE = 1; +dojo.dom.ATTRIBUTE_NODE = 2; +dojo.dom.TEXT_NODE = 3; +dojo.dom.CDATA_SECTION_NODE = 4; +dojo.dom.ENTITY_REFERENCE_NODE = 5; +dojo.dom.ENTITY_NODE = 6; +dojo.dom.PROCESSING_INSTRUCTION_NODE = 7; +dojo.dom.COMMENT_NODE = 8; +dojo.dom.DOCUMENT_NODE = 9; +dojo.dom.DOCUMENT_TYPE_NODE = 10; +dojo.dom.DOCUMENT_FRAGMENT_NODE = 11; +dojo.dom.NOTATION_NODE = 12; + +dojo.dom.dojoml = "http://www.dojotoolkit.org/2004/dojoml"; + +/** + * comprehensive list of XML namespaces +**/ +dojo.dom.xmlns = { + // summary + // aliases for various common XML namespaces + svg : "http://www.w3.org/2000/svg", + smil : "http://www.w3.org/2001/SMIL20/", + mml : "http://www.w3.org/1998/Math/MathML", + cml : "http://www.xml-cml.org", + xlink : "http://www.w3.org/1999/xlink", + xhtml : "http://www.w3.org/1999/xhtml", + xul : "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul", + xbl : "http://www.mozilla.org/xbl", + fo : "http://www.w3.org/1999/XSL/Format", + xsl : "http://www.w3.org/1999/XSL/Transform", + xslt : "http://www.w3.org/1999/XSL/Transform", + xi : "http://www.w3.org/2001/XInclude", + xforms : "http://www.w3.org/2002/01/xforms", + saxon : "http://icl.com/saxon", + xalan : "http://xml.apache.org/xslt", + xsd : "http://www.w3.org/2001/XMLSchema", + dt: "http://www.w3.org/2001/XMLSchema-datatypes", + xsi : "http://www.w3.org/2001/XMLSchema-instance", + rdf : "http://www.w3.org/1999/02/22-rdf-syntax-ns#", + rdfs : "http://www.w3.org/2000/01/rdf-schema#", + dc : "http://purl.org/dc/elements/1.1/", + dcq: "http://purl.org/dc/qualifiers/1.0", + "soap-env" : "http://schemas.xmlsoap.org/soap/envelope/", + wsdl : "http://schemas.xmlsoap.org/wsdl/", + AdobeExtensions : "http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/" +}; + +dojo.dom.isNode = function(/* object */wh){ + // summary: + // checks to see if wh is actually a node. + if(typeof Element == "function") { + try { + return wh instanceof Element; // boolean + } catch(e) {} + } else { + // best-guess + return wh && !isNaN(wh.nodeType); // boolean + } +} + +dojo.dom.getUniqueId = function(){ + // summary: + // returns a unique string for use with any DOM element + var _document = dojo.doc(); + do { + var id = "dj_unique_" + (++arguments.callee._idIncrement); + }while(_document.getElementById(id)); + return id; // string +} +dojo.dom.getUniqueId._idIncrement = 0; + +dojo.dom.firstElement = dojo.dom.getFirstChildElement = function(/* Element */parentNode, /* string? */tagName){ + // summary: + // returns the first child element matching tagName + var node = parentNode.firstChild; + while(node && node.nodeType != dojo.dom.ELEMENT_NODE){ + node = node.nextSibling; + } + if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) { + node = dojo.dom.nextElement(node, tagName); + } + return node; // Element +} + +dojo.dom.lastElement = dojo.dom.getLastChildElement = function(/* Element */parentNode, /* string? */tagName){ + // summary: + // returns the last child element matching tagName + var node = parentNode.lastChild; + while(node && node.nodeType != dojo.dom.ELEMENT_NODE) { + node = node.previousSibling; + } + if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) { + node = dojo.dom.prevElement(node, tagName); + } + return node; // Element +} + +dojo.dom.nextElement = dojo.dom.getNextSiblingElement = function(/* Node */node, /* string? */tagName){ + // summary: + // returns the next sibling element matching tagName + if(!node) { return null; } + do { + node = node.nextSibling; + } while(node && node.nodeType != dojo.dom.ELEMENT_NODE); + + if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) { + return dojo.dom.nextElement(node, tagName); + } + return node; // Element +} + +dojo.dom.prevElement = dojo.dom.getPreviousSiblingElement = function(/* Node */node, /* string? */tagName){ + // summary: + // returns the previous sibling element matching tagName + if(!node) { return null; } + if(tagName) { tagName = tagName.toLowerCase(); } + do { + node = node.previousSibling; + } while(node && node.nodeType != dojo.dom.ELEMENT_NODE); + + if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) { + return dojo.dom.prevElement(node, tagName); + } + return node; // Element +} + +// TODO: hmph +/*this.forEachChildTag = function(node, unaryFunc) { + var child = this.getFirstChildTag(node); + while(child) { + if(unaryFunc(child) == "break") { break; } + child = this.getNextSiblingTag(child); + } +}*/ + +dojo.dom.moveChildren = function(/*Element*/srcNode, /*Element*/destNode, /*boolean?*/trim){ + // summary: + // Moves children from srcNode to destNode and returns the count of + // children moved; will trim off text nodes if trim == true + var count = 0; + if(trim) { + while(srcNode.hasChildNodes() && + srcNode.firstChild.nodeType == dojo.dom.TEXT_NODE) { + srcNode.removeChild(srcNode.firstChild); + } + while(srcNode.hasChildNodes() && + srcNode.lastChild.nodeType == dojo.dom.TEXT_NODE) { + srcNode.removeChild(srcNode.lastChild); + } + } + while(srcNode.hasChildNodes()){ + destNode.appendChild(srcNode.firstChild); + count++; + } + return count; // number +} + +dojo.dom.copyChildren = function(/*Element*/srcNode, /*Element*/destNode, /*boolean?*/trim){ + // summary: + // Copies children from srcNde to destNode and returns the count of + // children copied; will trim off text nodes if trim == true + var clonedNode = srcNode.cloneNode(true); + return this.moveChildren(clonedNode, destNode, trim); // number +} + +dojo.dom.replaceChildren = function(/*Element*/node, /*Node*/newChild){ + // summary: + // Removes all children of node and appends newChild. All the existing + // children will be destroyed. + // FIXME: what if newChild is an array-like object? + var nodes = []; + if(dojo.render.html.ie){ + for(var i=0;i<node.childNodes.length;i++){ + nodes.push(node.childNodes[i]); + } + } + dojo.dom.removeChildren(node); + node.appendChild(newChild); + for(var i=0;i<nodes.length;i++){ + dojo.dom.destroyNode(nodes[i]); + } +} + +dojo.dom.removeChildren = function(/*Element*/node){ + // summary: + // removes all children from node and returns the count of children removed. + // The children nodes are not destroyed. Be sure to call destroyNode on them + // after they are not used anymore. + var count = node.childNodes.length; + while(node.hasChildNodes()){ dojo.dom.removeNode(node.firstChild); } + return count; // int +} + +dojo.dom.replaceNode = function(/*Element*/node, /*Element*/newNode){ + // summary: + // replaces node with newNode and returns a reference to the removed node. + // To prevent IE memory leak, call destroyNode on the returned node when + // it is no longer needed. + return node.parentNode.replaceChild(newNode, node); // Node +} + +dojo.dom.destroyNode = function(/*Node*/node){ + // summary: + // destroy a node (it can not be used any more). For IE, this is the + // right function to call to prevent memory leaks. While for other + // browsers, this is identical to dojo.dom.removeNode + if(node.parentNode){ + node = dojo.dom.removeNode(node); + } + if(node.nodeType != 3){ // ingore TEXT_NODE + if(dojo.evalObjPath("dojo.event.browser.clean", false)){ + dojo.event.browser.clean(node); + } + if(dojo.render.html.ie){ + node.outerHTML=''; //prevent ugly IE mem leak associated with Node.removeChild (ticket #1727) + } + } +} + +dojo.dom.removeNode = function(/*Node*/node){ + // summary: + // if node has a parent, removes node from parent and returns a + // reference to the removed child. + // To prevent IE memory leak, call destroyNode on the returned node when + // it is no longer needed. + // node: + // the node to remove from its parent. + + if(node && node.parentNode){ + // return a ref to the removed child + return node.parentNode.removeChild(node); //Node + } +} + +dojo.dom.getAncestors = function(/*Node*/node, /*function?*/filterFunction, /*boolean?*/returnFirstHit){ + // summary: + // returns all ancestors matching optional filterFunction; will return + // only the first if returnFirstHit + var ancestors = []; + var isFunction = (filterFunction && (filterFunction instanceof Function || typeof filterFunction == "function")); + while(node){ + if(!isFunction || filterFunction(node)){ + ancestors.push(node); + } + if(returnFirstHit && ancestors.length > 0){ + return ancestors[0]; // Node + } + + node = node.parentNode; + } + if(returnFirstHit){ return null; } + return ancestors; // array +} + +dojo.dom.getAncestorsByTag = function(/*Node*/node, /*String*/tag, /*boolean?*/returnFirstHit){ + // summary: + // returns all ancestors matching tag (as tagName), will only return + // first one if returnFirstHit + tag = tag.toLowerCase(); + return dojo.dom.getAncestors(node, function(el){ + return ((el.tagName)&&(el.tagName.toLowerCase() == tag)); + }, returnFirstHit); // Node || array +} + +dojo.dom.getFirstAncestorByTag = function(/*Node*/node, /*string*/tag){ + // summary: + // Returns first ancestor of node with tag tagName + return dojo.dom.getAncestorsByTag(node, tag, true); // Node +} + +dojo.dom.isDescendantOf = function(/* Node */node, /* Node */ancestor, /* boolean? */guaranteeDescendant){ + // summary + // Returns boolean if node is a descendant of ancestor + // guaranteeDescendant allows us to be a "true" isDescendantOf function + if(guaranteeDescendant && node) { node = node.parentNode; } + while(node) { + if(node == ancestor){ + return true; // boolean + } + node = node.parentNode; + } + return false; // boolean +} + +dojo.dom.innerXML = function(/*Node*/node){ + // summary: + // Implementation of MS's innerXML function. + if(node.innerXML){ + return node.innerXML; // string + }else if (node.xml){ + return node.xml; // string + }else if(typeof XMLSerializer != "undefined"){ + return (new XMLSerializer()).serializeToString(node); // string + } +} + +dojo.dom.createDocument = function(){ + // summary: + // cross-browser implementation of creating an XML document object. + var doc = null; + var _document = dojo.doc(); + + if(!dj_undef("ActiveXObject")){ + var prefixes = [ "MSXML2", "Microsoft", "MSXML", "MSXML3" ]; + for(var i = 0; i<prefixes.length; i++){ + try{ + doc = new ActiveXObject(prefixes[i]+".XMLDOM"); + }catch(e){ /* squelch */ }; + + if(doc){ break; } + } + }else if((_document.implementation)&& + (_document.implementation.createDocument)){ + doc = _document.implementation.createDocument("", "", null); + } + + return doc; // DOMDocument +} + +dojo.dom.createDocumentFromText = function(/*string*/str, /*string?*/mimetype){ + // summary: + // attempts to create a Document object based on optional mime-type, + // using str as the contents of the document + if(!mimetype){ mimetype = "text/xml"; } + if(!dj_undef("DOMParser")){ + var parser = new DOMParser(); + return parser.parseFromString(str, mimetype); // DOMDocument + }else if(!dj_undef("ActiveXObject")){ + var domDoc = dojo.dom.createDocument(); + if(domDoc){ + domDoc.async = false; + domDoc.loadXML(str); + return domDoc; // DOMDocument + }else{ + dojo.debug("toXml didn't work?"); + } + /* + }else if((dojo.render.html.capable)&&(dojo.render.html.safari)){ + // FIXME: this doesn't appear to work! + // from: http://web-graphics.com/mtarchive/001606.php + // var xml = '<?xml version="1.0"?>'+str; + var mtype = "text/xml"; + var xml = '<?xml version="1.0"?>'+str; + var url = "data:"+mtype+";charset=utf-8,"+encodeURIComponent(xml); + var req = new XMLHttpRequest(); + req.open("GET", url, false); + req.overrideMimeType(mtype); + req.send(null); + return req.responseXML; + */ + }else{ + var _document = dojo.doc(); + if(_document.createElement){ + // FIXME: this may change all tags to uppercase! + var tmp = _document.createElement("xml"); + tmp.innerHTML = str; + if(_document.implementation && _document.implementation.createDocument){ + var xmlDoc = _document.implementation.createDocument("foo", "", null); + for(var i = 0; i < tmp.childNodes.length; i++) { + xmlDoc.importNode(tmp.childNodes.item(i), true); + } + return xmlDoc; // DOMDocument + } + // FIXME: probably not a good idea to have to return an HTML fragment + // FIXME: the tmp.doc.firstChild is as tested from IE, so it may not + // work that way across the board + return ((tmp.document)&& + (tmp.document.firstChild ? tmp.document.firstChild : tmp)); // DOMDocument + } + } + return null; +} + +dojo.dom.prependChild = function(/*Element*/node, /*Element*/parent){ + // summary: + // prepends node to parent's children nodes + if(parent.firstChild) { + parent.insertBefore(node, parent.firstChild); + } else { + parent.appendChild(node); + } + return true; // boolean +} + +dojo.dom.insertBefore = function(/*Node*/node, /*Node*/ref, /*boolean?*/force){ + // summary: + // Try to insert node before ref + if( (force != true)&& + (node === ref || node.nextSibling === ref)){ return false; } + var parent = ref.parentNode; + parent.insertBefore(node, ref); + return true; // boolean +} + +dojo.dom.insertAfter = function(/*Node*/node, /*Node*/ref, /*boolean?*/force){ + // summary: + // Try to insert node after ref + var pn = ref.parentNode; + if(ref == pn.lastChild){ + if((force != true)&&(node === ref)){ + return false; // boolean + } + pn.appendChild(node); + }else{ + return this.insertBefore(node, ref.nextSibling, force); // boolean + } + return true; // boolean +} + +dojo.dom.insertAtPosition = function(/*Node*/node, /*Node*/ref, /*string*/position){ + // summary: + // attempt to insert node in relation to ref based on position + if((!node)||(!ref)||(!position)){ + return false; // boolean + } + switch(position.toLowerCase()){ + case "before": + return dojo.dom.insertBefore(node, ref); // boolean + case "after": + return dojo.dom.insertAfter(node, ref); // boolean + case "first": + if(ref.firstChild){ + return dojo.dom.insertBefore(node, ref.firstChild); // boolean + }else{ + ref.appendChild(node); + return true; // boolean + } + break; + default: // aka: last + ref.appendChild(node); + return true; // boolean + } +} + +dojo.dom.insertAtIndex = function(/*Node*/node, /*Element*/containingNode, /*number*/insertionIndex){ + // summary: + // insert node into child nodes nodelist of containingNode at + // insertionIndex. insertionIndex should be between 0 and + // the number of the childNodes in containingNode. insertionIndex + // specifys after how many childNodes in containingNode the node + // shall be inserted. If 0 is given, node will be appended to + // containingNode. + var siblingNodes = containingNode.childNodes; + + // if there aren't any kids yet, just add it to the beginning + + if (!siblingNodes.length || siblingNodes.length == insertionIndex){ + containingNode.appendChild(node); + return true; // boolean + } + + if(insertionIndex == 0){ + return dojo.dom.prependChild(node, containingNode); // boolean + } + // otherwise we need to walk the childNodes + // and find our spot + + return dojo.dom.insertAfter(node, siblingNodes[insertionIndex-1]); // boolean +} + +dojo.dom.textContent = function(/*Node*/node, /*string*/text){ + // summary: + // implementation of the DOM Level 3 attribute; scan node for text + if (arguments.length>1) { + var _document = dojo.doc(); + dojo.dom.replaceChildren(node, _document.createTextNode(text)); + return text; // string + } else { + if(node.textContent != undefined){ //FF 1.5 + return node.textContent; // string + } + var _result = ""; + if (node == null) { return _result; } + for (var i = 0; i < node.childNodes.length; i++) { + switch (node.childNodes[i].nodeType) { + case 1: // ELEMENT_NODE + case 5: // ENTITY_REFERENCE_NODE + _result += dojo.dom.textContent(node.childNodes[i]); + break; + case 3: // TEXT_NODE + case 2: // ATTRIBUTE_NODE + case 4: // CDATA_SECTION_NODE + _result += node.childNodes[i].nodeValue; + break; + default: + break; + } + } + return _result; // string + } +} + +dojo.dom.hasParent = function(/*Node*/node){ + // summary: + // returns whether or not node is a child of another node. + return Boolean(node && node.parentNode && dojo.dom.isNode(node.parentNode)); // boolean +} + +/** + * Examples: + * + * myFooNode = <foo /> + * isTag(myFooNode, "foo"); // returns "foo" + * isTag(myFooNode, "bar"); // returns "" + * isTag(myFooNode, "FOO"); // returns "" + * isTag(myFooNode, "hey", "foo", "bar"); // returns "foo" +**/ +dojo.dom.isTag = function(/* Node */node /* ... */){ + // summary: + // determines if node has any of the provided tag names and returns + // the tag name that matches, empty string otherwise. + if(node && node.tagName) { + for(var i=1; i<arguments.length; i++){ + if(node.tagName==String(arguments[i])){ + return String(arguments[i]); // string + } + } + } + return ""; // string +} + +dojo.dom.setAttributeNS = function( /*Element*/elem, /*string*/namespaceURI, + /*string*/attrName, /*string*/attrValue){ + // summary: + // implementation of DOM2 setAttributeNS that works cross browser. + if(elem == null || ((elem == undefined)&&(typeof elem == "undefined"))){ + dojo.raise("No element given to dojo.dom.setAttributeNS"); + } + + if(!((elem.setAttributeNS == undefined)&&(typeof elem.setAttributeNS == "undefined"))){ // w3c + elem.setAttributeNS(namespaceURI, attrName, attrValue); + }else{ // IE + // get a root XML document + var ownerDoc = elem.ownerDocument; + var attribute = ownerDoc.createNode( + 2, // node type + attrName, + namespaceURI + ); + + // set value + attribute.nodeValue = attrValue; + + // attach to element + elem.setAttributeNode(attribute); + } +} Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/dom.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/dom.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/dom.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/event.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/event.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/event.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/event.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,14 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.provide("dojo.event"); + +dojo.require("dojo.event.*"); +dojo.deprecated("dojo.event", "replaced by dojo.event.*", "0.5"); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/event.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/event.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/event.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/event/__package__.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/event/__package__.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/event/__package__.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/event/__package__.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,16 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.kwCompoundRequire({ + common: ["dojo.event.common", "dojo.event.topic"], + browser: ["dojo.event.browser"], + dashboard: ["dojo.event.browser"] +}); +dojo.provide("dojo.event.*"); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/event/__package__.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/event/__package__.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/event/__package__.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/event/browser.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/event/browser.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/event/browser.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/event/browser.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,550 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.provide("dojo.event.browser"); +dojo.require("dojo.event.common"); + +// FIXME: any particular reason this is in the global scope? +dojo._ie_clobber = new function(){ + this.clobberNodes = []; + + function nukeProp(node, prop){ + // try{ node.removeAttribute(prop); }catch(e){ /* squelch */ } + try{ node[prop] = null; }catch(e){ /* squelch */ } + try{ delete node[prop]; }catch(e){ /* squelch */ } + // FIXME: JotLive needs this, but I'm not sure if it's too slow or not + try{ node.removeAttribute(prop); }catch(e){ /* squelch */ } + } + + this.clobber = function(nodeRef){ + var na; + var tna; + if(nodeRef){ + tna = nodeRef.all || nodeRef.getElementsByTagName("*"); + na = [nodeRef]; + for(var x=0; x<tna.length; x++){ + // if we're gonna be clobbering the thing, at least make sure + // we aren't trying to do it twice + if(tna[x]["__doClobber__"]){ + na.push(tna[x]); + } + } + }else{ + try{ window.onload = null; }catch(e){} + na = (this.clobberNodes.length) ? this.clobberNodes : document.all; + } + tna = null; + var basis = {}; + for(var i = na.length-1; i>=0; i=i-1){ + var el = na[i]; + try{ + if(el && el["__clobberAttrs__"]){ + for(var j=0; j<el.__clobberAttrs__.length; j++){ + nukeProp(el, el.__clobberAttrs__[j]); + } + nukeProp(el, "__clobberAttrs__"); + nukeProp(el, "__doClobber__"); + } + }catch(e){ /* squelch! */}; + } + na = null; + } +} + +if(dojo.render.html.ie){ + dojo.addOnUnload(function(){ + dojo._ie_clobber.clobber(); + try{ + if((dojo["widget"])&&(dojo.widget["manager"])){ + dojo.widget.manager.destroyAll(); + } + }catch(e){} + + // Workaround for IE leak recommended in ticket #1727 by schallm + if(dojo.widget){ + for(var name in dojo.widget._templateCache){ + if(dojo.widget._templateCache[name].node){ + dojo.dom.destroyNode(dojo.widget._templateCache[name].node); + dojo.widget._templateCache[name].node = null; + delete dojo.widget._templateCache[name].node; + } + } + } + + try{ window.onload = null; }catch(e){} + try{ window.onunload = null; }catch(e){} + dojo._ie_clobber.clobberNodes = []; + // CollectGarbage(); + }); +} + +dojo.event.browser = new function(){ + + var clobberIdx = 0; + + this.normalizedEventName = function(/*String*/eventName){ + switch(eventName){ + case "CheckboxStateChange": + case "DOMAttrModified": + case "DOMMenuItemActive": + case "DOMMenuItemInactive": + case "DOMMouseScroll": + case "DOMNodeInserted": + case "DOMNodeRemoved": + case "RadioStateChange": + return eventName; + break; + default: + return eventName.toLowerCase(); + break; + } + } + + this.clean = function(/*DOMNode*/node){ + // summary: + // removes native event handlers so that destruction of the node + // will not leak memory. On most browsers this is a no-op, but + // it's critical for manual node removal on IE. + // node: + // A DOM node. All of it's children will also be cleaned. + if(dojo.render.html.ie){ + dojo._ie_clobber.clobber(node); + } + } + + this.addClobberNode = function(/*DOMNode*/node){ + // summary: + // register the passed node to support event stripping + // node: + // A DOM node + if(!dojo.render.html.ie){ return; } + if(!node["__doClobber__"]){ + node.__doClobber__ = true; + dojo._ie_clobber.clobberNodes.push(node); + // this might not be the most efficient thing to do, but it's + // much less error prone than other approaches which were + // previously tried and failed + node.__clobberAttrs__ = []; + } + } + + this.addClobberNodeAttrs = function(/*DOMNode*/node, /*Array*/props){ + // summary: + // register the passed node to support event stripping + // node: + // A DOM node to stip properties from later + // props: + // A list of propeties to strip from the node + if(!dojo.render.html.ie){ return; } + this.addClobberNode(node); + for(var x=0; x<props.length; x++){ + node.__clobberAttrs__.push(props[x]); + } + } + + this.removeListener = function( /*DOMNode*/ node, + /*String*/ evtName, + /*Function*/fp, + /*Boolean*/ capture){ + // summary: + // clobbers the listener from the node + // evtName: + // the name of the handler to remove the function from + // node: + // DOM node to attach the event to + // fp: + // the function to register + // capture: + // Optional. should this listener prevent propigation? + if(!capture){ var capture = false; } + evtName = dojo.event.browser.normalizedEventName(evtName); + if( (evtName == "onkey") || (evtName == "key") ){ + if(dojo.render.html.ie){ + this.removeListener(node, "onkeydown", fp, capture); + } + evtName = "onkeypress"; + } + if(evtName.substr(0,2)=="on"){ evtName = evtName.substr(2); } + // FIXME: this is mostly a punt, we aren't actually doing anything on IE + if(node.removeEventListener){ + node.removeEventListener(evtName, fp, capture); + } + } + + this.addListener = function(/*DOMNode*/node, /*String*/evtName, /*Function*/fp, /*Boolean*/capture, /*Boolean*/dontFix){ + // summary: + // adds a listener to the node + // evtName: + // the name of the handler to add the listener to can be either of + // the form "onclick" or "click" + // node: + // DOM node to attach the event to + // fp: + // the function to register + // capture: + // Optional. Should this listener prevent propigation? + // dontFix: + // Optional. Should we avoid registering a new closure around the + // listener to enable fixEvent for dispatch of the registered + // function? + if(!node){ return; } // FIXME: log and/or bail? + if(!capture){ var capture = false; } + evtName = dojo.event.browser.normalizedEventName(evtName); + if( (evtName == "onkey") || (evtName == "key") ){ + if(dojo.render.html.ie){ + this.addListener(node, "onkeydown", fp, capture, dontFix); + } + evtName = "onkeypress"; + } + if(evtName.substr(0,2)!="on"){ evtName = "on"+evtName; } + + if(!dontFix){ + // build yet another closure around fp in order to inject fixEvent + // around the resulting event + var newfp = function(evt){ + if(!evt){ evt = window.event; } + var ret = fp(dojo.event.browser.fixEvent(evt, this)); + if(capture){ + dojo.event.browser.stopEvent(evt); + } + return ret; + } + }else{ + newfp = fp; + } + + if(node.addEventListener){ + node.addEventListener(evtName.substr(2), newfp, capture); + return newfp; + }else{ + if(typeof node[evtName] == "function" ){ + var oldEvt = node[evtName]; + node[evtName] = function(e){ + oldEvt(e); + return newfp(e); + } + }else{ + node[evtName]=newfp; + } + if(dojo.render.html.ie){ + this.addClobberNodeAttrs(node, [evtName]); + } + return newfp; + } + } + + this.isEvent = function(/*Object*/obj){ + // summary: + // Tries to determine whether or not the object is a DOM event. + + // FIXME: event detection hack ... could test for additional attributes + // if necessary + return (typeof obj != "undefined")&&(obj)&&(typeof Event != "undefined")&&(obj.eventPhase); // Boolean + // Event does not support instanceof in Opera, otherwise: + //return (typeof Event != "undefined")&&(obj instanceof Event); + } + + this.currentEvent = null; + + this.callListener = function(/*Function*/listener, /*DOMNode*/curTarget){ + // summary: + // calls the specified listener in the context of the passed node + // with the current DOM event object as the only parameter + // listener: + // the function to call + // curTarget: + // the Node to call the function in the scope of + if(typeof listener != 'function'){ + dojo.raise("listener not a function: " + listener); + } + dojo.event.browser.currentEvent.currentTarget = curTarget; + return listener.call(curTarget, dojo.event.browser.currentEvent); + } + + this._stopPropagation = function(){ + dojo.event.browser.currentEvent.cancelBubble = true; + } + + this._preventDefault = function(){ + dojo.event.browser.currentEvent.returnValue = false; + } + + this.keys = { + KEY_BACKSPACE: 8, + KEY_TAB: 9, + KEY_CLEAR: 12, + KEY_ENTER: 13, + KEY_SHIFT: 16, + KEY_CTRL: 17, + KEY_ALT: 18, + KEY_PAUSE: 19, + KEY_CAPS_LOCK: 20, + KEY_ESCAPE: 27, + KEY_SPACE: 32, + KEY_PAGE_UP: 33, + KEY_PAGE_DOWN: 34, + KEY_END: 35, + KEY_HOME: 36, + KEY_LEFT_ARROW: 37, + KEY_UP_ARROW: 38, + KEY_RIGHT_ARROW: 39, + KEY_DOWN_ARROW: 40, + KEY_INSERT: 45, + KEY_DELETE: 46, + KEY_HELP: 47, + KEY_LEFT_WINDOW: 91, + KEY_RIGHT_WINDOW: 92, + KEY_SELECT: 93, + KEY_NUMPAD_0: 96, + KEY_NUMPAD_1: 97, + KEY_NUMPAD_2: 98, + KEY_NUMPAD_3: 99, + KEY_NUMPAD_4: 100, + KEY_NUMPAD_5: 101, + KEY_NUMPAD_6: 102, + KEY_NUMPAD_7: 103, + KEY_NUMPAD_8: 104, + KEY_NUMPAD_9: 105, + KEY_NUMPAD_MULTIPLY: 106, + KEY_NUMPAD_PLUS: 107, + KEY_NUMPAD_ENTER: 108, + KEY_NUMPAD_MINUS: 109, + KEY_NUMPAD_PERIOD: 110, + KEY_NUMPAD_DIVIDE: 111, + KEY_F1: 112, + KEY_F2: 113, + KEY_F3: 114, + KEY_F4: 115, + KEY_F5: 116, + KEY_F6: 117, + KEY_F7: 118, + KEY_F8: 119, + KEY_F9: 120, + KEY_F10: 121, + KEY_F11: 122, + KEY_F12: 123, + KEY_F13: 124, + KEY_F14: 125, + KEY_F15: 126, + KEY_NUM_LOCK: 144, + KEY_SCROLL_LOCK: 145 + }; + + // reverse lookup + this.revKeys = []; + for(var key in this.keys){ + this.revKeys[this.keys[key]] = key; + } + + this.fixEvent = function(/*Event*/evt, /*DOMNode*/sender){ + // summary: + // normalizes properties on the event object including event + // bubbling methods, keystroke normalization, and x/y positions + // evt: the native event object + // sender: the node to treat as "currentTarget" + if(!evt){ + if(window["event"]){ + evt = window.event; + } + } + + if((evt["type"])&&(evt["type"].indexOf("key") == 0)){ // key events + evt.keys = this.revKeys; + // FIXME: how can we eliminate this iteration? + for(var key in this.keys){ + evt[key] = this.keys[key]; + } + if(evt["type"] == "keydown" && dojo.render.html.ie){ + switch(evt.keyCode){ + case evt.KEY_SHIFT: + case evt.KEY_CTRL: + case evt.KEY_ALT: + case evt.KEY_CAPS_LOCK: + case evt.KEY_LEFT_WINDOW: + case evt.KEY_RIGHT_WINDOW: + case evt.KEY_SELECT: + case evt.KEY_NUM_LOCK: + case evt.KEY_SCROLL_LOCK: + // I'll get these in keypress after the OS munges them based on numlock + case evt.KEY_NUMPAD_0: + case evt.KEY_NUMPAD_1: + case evt.KEY_NUMPAD_2: + case evt.KEY_NUMPAD_3: + case evt.KEY_NUMPAD_4: + case evt.KEY_NUMPAD_5: + case evt.KEY_NUMPAD_6: + case evt.KEY_NUMPAD_7: + case evt.KEY_NUMPAD_8: + case evt.KEY_NUMPAD_9: + case evt.KEY_NUMPAD_PERIOD: + break; // just ignore the keys that can morph + case evt.KEY_NUMPAD_MULTIPLY: + case evt.KEY_NUMPAD_PLUS: + case evt.KEY_NUMPAD_ENTER: + case evt.KEY_NUMPAD_MINUS: + case evt.KEY_NUMPAD_DIVIDE: + break; // I could handle these but just pick them up in keypress + case evt.KEY_PAUSE: + case evt.KEY_TAB: + case evt.KEY_BACKSPACE: + case evt.KEY_ENTER: + case evt.KEY_ESCAPE: + case evt.KEY_PAGE_UP: + case evt.KEY_PAGE_DOWN: + case evt.KEY_END: + case evt.KEY_HOME: + case evt.KEY_LEFT_ARROW: + case evt.KEY_UP_ARROW: + case evt.KEY_RIGHT_ARROW: + case evt.KEY_DOWN_ARROW: + case evt.KEY_INSERT: + case evt.KEY_DELETE: + case evt.KEY_F1: + case evt.KEY_F2: + case evt.KEY_F3: + case evt.KEY_F4: + case evt.KEY_F5: + case evt.KEY_F6: + case evt.KEY_F7: + case evt.KEY_F8: + case evt.KEY_F9: + case evt.KEY_F10: + case evt.KEY_F11: + case evt.KEY_F12: + case evt.KEY_F12: + case evt.KEY_F13: + case evt.KEY_F14: + case evt.KEY_F15: + case evt.KEY_CLEAR: + case evt.KEY_HELP: + evt.key = evt.keyCode; + break; + default: + if(evt.ctrlKey || evt.altKey){ + var unifiedCharCode = evt.keyCode; + // if lower case but keycode is uppercase, convert it + if(unifiedCharCode >= 65 && unifiedCharCode <= 90 && evt.shiftKey == false){ + unifiedCharCode += 32; + } + if(unifiedCharCode >= 1 && unifiedCharCode <= 26 && evt.ctrlKey){ + unifiedCharCode += 96; // 001-032 = ctrl+[a-z] + } + evt.key = String.fromCharCode(unifiedCharCode); + } + } + } else if(evt["type"] == "keypress"){ + if(dojo.render.html.opera){ + if(evt.which == 0){ + evt.key = evt.keyCode; + }else if(evt.which > 0){ + switch(evt.which){ + case evt.KEY_SHIFT: + case evt.KEY_CTRL: + case evt.KEY_ALT: + case evt.KEY_CAPS_LOCK: + case evt.KEY_NUM_LOCK: + case evt.KEY_SCROLL_LOCK: + break; + case evt.KEY_PAUSE: + case evt.KEY_TAB: + case evt.KEY_BACKSPACE: + case evt.KEY_ENTER: + case evt.KEY_ESCAPE: + evt.key = evt.which; + break; + default: + var unifiedCharCode = evt.which; + if((evt.ctrlKey || evt.altKey || evt.metaKey) && (evt.which >= 65 && evt.which <= 90 && evt.shiftKey == false)){ + unifiedCharCode += 32; + } + evt.key = String.fromCharCode(unifiedCharCode); + } + } + }else if(dojo.render.html.ie){ // catch some IE keys that are hard to get in keyDown + // key combinations were handled in onKeyDown + if(!evt.ctrlKey && !evt.altKey && evt.keyCode >= evt.KEY_SPACE){ + evt.key = String.fromCharCode(evt.keyCode); + } + }else if(dojo.render.html.safari){ + switch(evt.keyCode){ + case 25: evt.key = evt.KEY_TAB; evt.shift = true;break; + case 63232: evt.key = evt.KEY_UP_ARROW; break; + case 63233: evt.key = evt.KEY_DOWN_ARROW; break; + case 63234: evt.key = evt.KEY_LEFT_ARROW; break; + case 63235: evt.key = evt.KEY_RIGHT_ARROW; break; + case 63236: evt.key = evt.KEY_F1; break; + case 63237: evt.key = evt.KEY_F2; break; + case 63238: evt.key = evt.KEY_F3; break; + case 63239: evt.key = evt.KEY_F4; break; + case 63240: evt.key = evt.KEY_F5; break; + case 63241: evt.key = evt.KEY_F6; break; + case 63242: evt.key = evt.KEY_F7; break; + case 63243: evt.key = evt.KEY_F8; break; + case 63244: evt.key = evt.KEY_F9; break; + case 63245: evt.key = evt.KEY_F10; break; + case 63246: evt.key = evt.KEY_F11; break; + case 63247: evt.key = evt.KEY_F12; break; + case 63250: evt.key = evt.KEY_PAUSE; break; + case 63272: evt.key = evt.KEY_DELETE; break; + case 63273: evt.key = evt.KEY_HOME; break; + case 63275: evt.key = evt.KEY_END; break; + case 63276: evt.key = evt.KEY_PAGE_UP; break; + case 63277: evt.key = evt.KEY_PAGE_DOWN; break; + case 63302: evt.key = evt.KEY_INSERT; break; + case 63248://prtscr + case 63249://scrolllock + case 63289://numlock + break; + default: + evt.key = evt.charCode >= evt.KEY_SPACE ? String.fromCharCode(evt.charCode) : evt.keyCode; + } + }else{ + evt.key = evt.charCode > 0 ? String.fromCharCode(evt.charCode) : evt.keyCode; + } + } + } + if(dojo.render.html.ie){ + if(!evt.target){ evt.target = evt.srcElement; } + if(!evt.currentTarget){ evt.currentTarget = (sender ? sender : evt.srcElement); } + if(!evt.layerX){ evt.layerX = evt.offsetX; } + if(!evt.layerY){ evt.layerY = evt.offsetY; } + // FIXME: scroll position query is duped from dojo.html to avoid dependency on that entire module + // DONOT replace the following to use dojo.body(), in IE, document.documentElement should be used + // here rather than document.body + var doc = (evt.srcElement && evt.srcElement.ownerDocument) ? evt.srcElement.ownerDocument : document; + var docBody = ((dojo.render.html.ie55)||(doc["compatMode"] == "BackCompat")) ? doc.body : doc.documentElement; + if(!evt.pageX){ evt.pageX = evt.clientX + (docBody.scrollLeft || 0) } + if(!evt.pageY){ evt.pageY = evt.clientY + (docBody.scrollTop || 0) } + // mouseover + if(evt.type == "mouseover"){ evt.relatedTarget = evt.fromElement; } + // mouseout + if(evt.type == "mouseout"){ evt.relatedTarget = evt.toElement; } + this.currentEvent = evt; + evt.callListener = this.callListener; + evt.stopPropagation = this._stopPropagation; + evt.preventDefault = this._preventDefault; + } + return evt; // Event + } + + this.stopEvent = function(/*Event*/evt){ + // summary: + // prevents propigation and clobbers the default action of the + // passed event + // evt: Optional for IE. The native event object. + if(window.event){ + evt.cancelBubble = true; + evt.returnValue = false; + }else{ + evt.preventDefault(); + evt.stopPropagation(); + } + } +} Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/event/browser.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/event/browser.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/event/browser.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/event/common.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/event/common.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/event/common.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/event/common.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,885 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.provide("dojo.event.common"); + +dojo.require("dojo.lang.array"); +dojo.require("dojo.lang.extras"); +dojo.require("dojo.lang.func"); + +// TODO: connection filter functions +// these are functions that accept a method invocation (like around +// advice) and return a boolean based on it. That value determines +// whether or not the connection proceeds. It could "feel" like around +// advice for those who know what it is (calling proceed() or not), +// but I think presenting it as a "filter" and/or calling it with the +// function args and not the MethodInvocation might make it more +// palletable to "normal" users than around-advice currently is +// TODO: execution scope mangling +// YUI's event facility by default executes listeners in the context +// of the source object. This is very odd, but should probably be +// supported as an option (both for the source and for the dest). It +// can be thought of as a connection-specific hitch(). +// TODO: more resiliency for 4+ arguments to connect() + +dojo.event = new function(){ + this._canTimeout = dojo.lang.isFunction(dj_global["setTimeout"])||dojo.lang.isAlien(dj_global["setTimeout"]); + + // FIXME: where should we put this method (not here!)? + function interpolateArgs(args, searchForNames){ + var dl = dojo.lang; + var ao = { + srcObj: dj_global, + srcFunc: null, + adviceObj: dj_global, + adviceFunc: null, + aroundObj: null, + aroundFunc: null, + adviceType: (args.length>2) ? args[0] : "after", + precedence: "last", + once: false, + delay: null, + rate: 0, + adviceMsg: false + }; + + switch(args.length){ + case 0: return; + case 1: return; + case 2: + ao.srcFunc = args[0]; + ao.adviceFunc = args[1]; + break; + case 3: + if((dl.isObject(args[0]))&&(dl.isString(args[1]))&&(dl.isString(args[2]))){ + ao.adviceType = "after"; + ao.srcObj = args[0]; + ao.srcFunc = args[1]; + ao.adviceFunc = args[2]; + }else if((dl.isString(args[1]))&&(dl.isString(args[2]))){ + ao.srcFunc = args[1]; + ao.adviceFunc = args[2]; + }else if((dl.isObject(args[0]))&&(dl.isString(args[1]))&&(dl.isFunction(args[2]))){ + ao.adviceType = "after"; + ao.srcObj = args[0]; + ao.srcFunc = args[1]; + var tmpName = dl.nameAnonFunc(args[2], ao.adviceObj, searchForNames); + ao.adviceFunc = tmpName; + }else if((dl.isFunction(args[0]))&&(dl.isObject(args[1]))&&(dl.isString(args[2]))){ + ao.adviceType = "after"; + ao.srcObj = dj_global; + var tmpName = dl.nameAnonFunc(args[0], ao.srcObj, searchForNames); + ao.srcFunc = tmpName; + ao.adviceObj = args[1]; + ao.adviceFunc = args[2]; + } + break; + case 4: + if((dl.isObject(args[0]))&&(dl.isObject(args[2]))){ + // we can assume that we've got an old-style "connect" from + // the sigslot school of event attachment. We therefore + // assume after-advice. + ao.adviceType = "after"; + ao.srcObj = args[0]; + ao.srcFunc = args[1]; + ao.adviceObj = args[2]; + ao.adviceFunc = args[3]; + }else if((dl.isString(args[0]))&&(dl.isString(args[1]))&&(dl.isObject(args[2]))){ + ao.adviceType = args[0]; + ao.srcObj = dj_global; + ao.srcFunc = args[1]; + ao.adviceObj = args[2]; + ao.adviceFunc = args[3]; + }else if((dl.isString(args[0]))&&(dl.isFunction(args[1]))&&(dl.isObject(args[2]))){ + ao.adviceType = args[0]; + ao.srcObj = dj_global; + var tmpName = dl.nameAnonFunc(args[1], dj_global, searchForNames); + ao.srcFunc = tmpName; + ao.adviceObj = args[2]; + ao.adviceFunc = args[3]; + }else if((dl.isString(args[0]))&&(dl.isObject(args[1]))&&(dl.isString(args[2]))&&(dl.isFunction(args[3]))){ + ao.srcObj = args[1]; + ao.srcFunc = args[2]; + var tmpName = dl.nameAnonFunc(args[3], dj_global, searchForNames); + ao.adviceObj = dj_global; + ao.adviceFunc = tmpName; + }else if(dl.isObject(args[1])){ + ao.srcObj = args[1]; + ao.srcFunc = args[2]; + ao.adviceObj = dj_global; + ao.adviceFunc = args[3]; + }else if(dl.isObject(args[2])){ + ao.srcObj = dj_global; + ao.srcFunc = args[1]; + ao.adviceObj = args[2]; + ao.adviceFunc = args[3]; + }else{ + ao.srcObj = ao.adviceObj = ao.aroundObj = dj_global; + ao.srcFunc = args[1]; + ao.adviceFunc = args[2]; + ao.aroundFunc = args[3]; + } + break; + case 6: + ao.srcObj = args[1]; + ao.srcFunc = args[2]; + ao.adviceObj = args[3] + ao.adviceFunc = args[4]; + ao.aroundFunc = args[5]; + ao.aroundObj = dj_global; + break; + default: + ao.srcObj = args[1]; + ao.srcFunc = args[2]; + ao.adviceObj = args[3] + ao.adviceFunc = args[4]; + ao.aroundObj = args[5]; + ao.aroundFunc = args[6]; + ao.once = args[7]; + ao.delay = args[8]; + ao.rate = args[9]; + ao.adviceMsg = args[10]; + break; + } + + if(dl.isFunction(ao.aroundFunc)){ + var tmpName = dl.nameAnonFunc(ao.aroundFunc, ao.aroundObj, searchForNames); + ao.aroundFunc = tmpName; + } + + if(dl.isFunction(ao.srcFunc)){ + ao.srcFunc = dl.getNameInObj(ao.srcObj, ao.srcFunc); + } + + if(dl.isFunction(ao.adviceFunc)){ + ao.adviceFunc = dl.getNameInObj(ao.adviceObj, ao.adviceFunc); + } + + if((ao.aroundObj)&&(dl.isFunction(ao.aroundFunc))){ + ao.aroundFunc = dl.getNameInObj(ao.aroundObj, ao.aroundFunc); + } + + if(!ao.srcObj){ + dojo.raise("bad srcObj for srcFunc: "+ao.srcFunc); + } + if(!ao.adviceObj){ + dojo.raise("bad adviceObj for adviceFunc: "+ao.adviceFunc); + } + + if(!ao.adviceFunc){ + dojo.debug("bad adviceFunc for srcFunc: "+ao.srcFunc); + dojo.debugShallow(ao); + } + + return ao; + } + + this.connect = function(/*...*/){ + // summary: + // dojo.event.connect is the glue that holds most Dojo-based + // applications together. Most combinations of arguments are + // supported, with the connect() method attempting to disambiguate + // the implied types of positional parameters. The following will + // all work: + // dojo.event.connect("globalFunctionName1", "globalFunctionName2"); + // dojo.event.connect(functionReference1, functionReference2); + // dojo.event.connect("globalFunctionName1", functionReference2); + // dojo.event.connect(functionReference1, "globalFunctionName2"); + // dojo.event.connect(scope1, "functionName1", "globalFunctionName2"); + // dojo.event.connect("globalFunctionName1", scope2, "functionName2"); + // dojo.event.connect(scope1, "functionName1", scope2, "functionName2"); + // dojo.event.connect("after", scope1, "functionName1", scope2, "functionName2"); + // dojo.event.connect("before", scope1, "functionName1", scope2, "functionName2"); + // dojo.event.connect("around", scope1, "functionName1", + // scope2, "functionName2", + // aroundFunctionReference); + // dojo.event.connect("around", scope1, "functionName1", + // scope2, "functionName2", + // scope3, "aroundFunctionName"); + // dojo.event.connect("before-around", scope1, "functionName1", + // scope2, "functionName2", + // aroundFunctionReference); + // dojo.event.connect("after-around", scope1, "functionName1", + // scope2, "functionName2", + // aroundFunctionReference); + // dojo.event.connect("after-around", scope1, "functionName1", + // scope2, "functionName2", + // scope3, "aroundFunctionName"); + // dojo.event.connect("around", scope1, "functionName1", + // scope2, "functionName2", + // scope3, "aroundFunctionName", true, 30); + // dojo.event.connect("around", scope1, "functionName1", + // scope2, "functionName2", + // scope3, "aroundFunctionName", null, null, 10); + // adviceType: + // Optional. String. One of "before", "after", "around", + // "before-around", or "after-around". FIXME + // srcObj: + // the scope in which to locate/execute the named srcFunc. Along + // with srcFunc, this creates a way to dereference the function to + // call. So if the function in question is "foo.bar", the + // srcObj/srcFunc pair would be foo and "bar", where "bar" is a + // string and foo is an object reference. + // srcFunc: + // the name of the function to connect to. When it is executed, + // the listener being registered with this call will be called. + // The adviceType defines the call order between the source and + // the target functions. + // adviceObj: + // the scope in which to locate/execute the named adviceFunc. + // adviceFunc: + // the name of the function being conected to srcObj.srcFunc + // aroundObj: + // the scope in which to locate/execute the named aroundFunc. + // aroundFunc: + // the name of, or a reference to, the function that will be used + // to mediate the advice call. Around advice requires a special + // unary function that will be passed a "MethodInvocation" object. + // These objects have several important properties, namely: + // - args + // a mutable array of arguments to be passed into the + // wrapped function + // - proceed + // a function that "continues" the invocation. The result + // of this function is the return of the wrapped function. + // You can then manipulate this return before passing it + // back out (or take further action based on it). + // once: + // boolean that determines whether or not this connect() will + // create a new connection if an identical connect() has already + // been made. Defaults to "false". + // delay: + // an optional delay (in ms), as an integer, for dispatch of a + // listener after the source has been fired. + // rate: + // an optional rate throttling parameter (integer, in ms). When + // specified, this particular connection will not fire more than + // once in the interval specified by the rate + // adviceMsg: + // boolean. Should the listener have all the parameters passed in + // as a single argument? + + /* + ao.adviceType = args[0]; + ao.srcObj = args[1]; + ao.srcFunc = args[2]; + ao.adviceObj = args[3] + ao.adviceFunc = args[4]; + ao.aroundObj = args[5]; + ao.aroundFunc = args[6]; + ao.once = args[7]; + ao.delay = args[8]; + ao.rate = args[9]; + ao.adviceMsg = args[10]; + */ + if(arguments.length == 1){ + var ao = arguments[0]; + }else{ + var ao = interpolateArgs(arguments, true); + } + if(dojo.lang.isString(ao.srcFunc) && (ao.srcFunc.toLowerCase() == "onkey") ){ + if(dojo.render.html.ie){ + ao.srcFunc = "onkeydown"; + this.connect(ao); + } + ao.srcFunc = "onkeypress"; + } + + + if(dojo.lang.isArray(ao.srcObj) && ao.srcObj!=""){ + var tmpAO = {}; + for(var x in ao){ + tmpAO[x] = ao[x]; + } + var mjps = []; + dojo.lang.forEach(ao.srcObj, function(src){ + if((dojo.render.html.capable)&&(dojo.lang.isString(src))){ + src = dojo.byId(src); + // dojo.debug(src); + } + tmpAO.srcObj = src; + // dojo.debug(tmpAO.srcObj, tmpAO.srcFunc); + // dojo.debug(tmpAO.adviceObj, tmpAO.adviceFunc); + mjps.push(dojo.event.connect.call(dojo.event, tmpAO)); + }); + return mjps; + } + + // FIXME: just doing a "getForMethod()" seems to be enough to put this into infinite recursion!! + var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc); + if(ao.adviceFunc){ + var mjp2 = dojo.event.MethodJoinPoint.getForMethod(ao.adviceObj, ao.adviceFunc); + } + + mjp.kwAddAdvice(ao); + + // advanced users might want to fsck w/ the join point manually + return mjp; // a MethodJoinPoint object + } + + this.log = function(/*object or funcName*/ a1, /*funcName*/ a2){ + // summary: + // a function that will wrap and log all calls to the specified + // a1.a2() function. If only a1 is passed, it'll be used as a + // function or function name on the global context. Logging will + // be sent to dojo.debug + // a1: + // if a2 is passed, this should be an object. If not, it can be a + // function or function name. + // a2: + // a function name + var kwArgs; + if((arguments.length == 1)&&(typeof a1 == "object")){ + kwArgs = a1; + }else{ + kwArgs = { + srcObj: a1, + srcFunc: a2 + }; + } + kwArgs.adviceFunc = function(){ + var argsStr = []; + for(var x=0; x<arguments.length; x++){ + argsStr.push(arguments[x]); + } + dojo.debug("("+kwArgs.srcObj+")."+kwArgs.srcFunc, ":", argsStr.join(", ")); + } + this.kwConnect(kwArgs); + } + + this.connectBefore = function(){ + // summary: + // takes the same parameters as dojo.event.connect(), except that + // the advice type will always be "before" + var args = ["before"]; + for(var i = 0; i < arguments.length; i++){ args.push(arguments[i]); } + return this.connect.apply(this, args); // a MethodJoinPoint object + } + + this.connectAround = function(){ + // summary: + // takes the same parameters as dojo.event.connect(), except that + // the advice type will always be "around" + var args = ["around"]; + for(var i = 0; i < arguments.length; i++){ args.push(arguments[i]); } + return this.connect.apply(this, args); // a MethodJoinPoint object + } + + this.connectOnce = function(){ + // summary: + // takes the same parameters as dojo.event.connect(), except that + // the "once" flag will always be set to "true" + var ao = interpolateArgs(arguments, true); + ao.once = true; + return this.connect(ao); // a MethodJoinPoint object + } + + this._kwConnectImpl = function(kwArgs, disconnect){ + var fn = (disconnect) ? "disconnect" : "connect"; + if(typeof kwArgs["srcFunc"] == "function"){ + kwArgs.srcObj = kwArgs["srcObj"]||dj_global; + var tmpName = dojo.lang.nameAnonFunc(kwArgs.srcFunc, kwArgs.srcObj, true); + kwArgs.srcFunc = tmpName; + } + if(typeof kwArgs["adviceFunc"] == "function"){ + kwArgs.adviceObj = kwArgs["adviceObj"]||dj_global; + var tmpName = dojo.lang.nameAnonFunc(kwArgs.adviceFunc, kwArgs.adviceObj, true); + kwArgs.adviceFunc = tmpName; + } + kwArgs.srcObj = kwArgs["srcObj"]||dj_global; + kwArgs.adviceObj = kwArgs["adviceObj"]||kwArgs["targetObj"]||dj_global; + kwArgs.adviceFunc = kwArgs["adviceFunc"]||kwArgs["targetFunc"]; + // pass kwargs to avoid unrolling/repacking + return dojo.event[fn](kwArgs); + } + + this.kwConnect = function(/*Object*/ kwArgs){ + // summary: + // A version of dojo.event.connect() that takes a map of named + // parameters instead of the positional parameters that + // dojo.event.connect() uses. For many advanced connection types, + // this can be a much more readable (and potentially faster) + // alternative. + // kwArgs: + // An object that can have the following properties: + // - adviceType + // - srcObj + // - srcFunc + // - adviceObj + // - adviceFunc + // - aroundObj + // - aroundFunc + // - once + // - delay + // - rate + // - adviceMsg + // As with connect, only srcFunc and adviceFunc are generally + // required + + return this._kwConnectImpl(kwArgs, false); // a MethodJoinPoint object + + } + + this.disconnect = function(){ + // summary: + // Takes the same parameters as dojo.event.connect() but destroys + // an existing connection instead of building a new one. For + // multiple identical connections, multiple disconnect() calls + // will unroll one each time it's called. + if(arguments.length == 1){ + var ao = arguments[0]; + }else{ + var ao = interpolateArgs(arguments, true); + } + if(!ao.adviceFunc){ return; } // nothing to disconnect + if(dojo.lang.isString(ao.srcFunc) && (ao.srcFunc.toLowerCase() == "onkey") ){ + if(dojo.render.html.ie){ + ao.srcFunc = "onkeydown"; + this.disconnect(ao); + } + ao.srcFunc = "onkeypress"; + } + if(!ao.srcObj[ao.srcFunc]){ return null; } // prevent un-necessaray joinpoint creation + var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc, true); + mjp.removeAdvice(ao.adviceObj, ao.adviceFunc, ao.adviceType, ao.once); // a MethodJoinPoint object + return mjp; + } + + this.kwDisconnect = function(kwArgs){ + // summary: + // Takes the same parameters as dojo.event.kwConnect() but + // destroys an existing connection instead of building a new one. + return this._kwConnectImpl(kwArgs, true); + } +} + +// exactly one of these is created whenever a method with a joint point is run, +// if there is at least one 'around' advice. +dojo.event.MethodInvocation = function(/*dojo.event.MethodJoinPoint*/join_point, /*Object*/obj, /*Array*/args){ + // summary: + // a class the models the call into a function. This is used under the + // covers for all method invocations on both ends of a + // connect()-wrapped function dispatch. This allows us to "pickle" + // calls, such as in the case of around advice. + // join_point: + // a dojo.event.MethodJoinPoint object that represents a connection + // obj: + // the scope the call will execute in + // args: + // an array of parameters that will get passed to the callee + this.jp_ = join_point; + this.object = obj; + this.args = []; + // make sure we don't lock into a mutable object which can change under us. + // It's ok if the individual items change, though. + for(var x=0; x<args.length; x++){ + this.args[x] = args[x]; + } + // the index of the 'around' that is currently being executed. + this.around_index = -1; +} + +dojo.event.MethodInvocation.prototype.proceed = function(){ + // summary: + // proceed with the method call that's represented by this invocation + // object + this.around_index++; + if(this.around_index >= this.jp_.around.length){ + return this.jp_.object[this.jp_.methodname].apply(this.jp_.object, this.args); + // return this.jp_.run_before_after(this.object, this.args); + }else{ + var ti = this.jp_.around[this.around_index]; + var mobj = ti[0]||dj_global; + var meth = ti[1]; + return mobj[meth].call(mobj, this); + } +} + + +dojo.event.MethodJoinPoint = function(/*Object*/obj, /*String*/funcName){ + this.object = obj||dj_global; + this.methodname = funcName; + this.methodfunc = this.object[funcName]; + this.squelch = false; + // this.before = []; + // this.after = []; + // this.around = []; +} + +dojo.event.MethodJoinPoint.getForMethod = function(/*Object*/obj, /*String*/funcName){ + // summary: + // "static" class function for returning a MethodJoinPoint from a + // scoped function. If one doesn't exist, one is created. + // obj: + // the scope to search for the function in + // funcName: + // the name of the function to return a MethodJoinPoint for + if(!obj){ obj = dj_global; } + if(!obj[funcName]){ + // supply a do-nothing method implementation + obj[funcName] = function(){}; + if(!obj[funcName]){ + // e.g. cannot add to inbuilt objects in IE6 + dojo.raise("Cannot set do-nothing method on that object "+funcName); + } + }else if((!dojo.lang.isFunction(obj[funcName]))&&(!dojo.lang.isAlien(obj[funcName]))){ + // FIXME: should we throw an exception here instead? + return null; + } + // we hide our joinpoint instance in obj[funcName + '$joinpoint'] + var jpname = funcName + "$joinpoint"; + var jpfuncname = funcName + "$joinpoint$method"; + var joinpoint = obj[jpname]; + if(!joinpoint){ + var isNode = false; + if(dojo.event["browser"]){ + if( (obj["attachEvent"])|| + (obj["nodeType"])|| + (obj["addEventListener"]) ){ + isNode = true; + dojo.event.browser.addClobberNodeAttrs(obj, [jpname, jpfuncname, funcName]); + } + } + var origArity = obj[funcName].length; + obj[jpfuncname] = obj[funcName]; + // joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, funcName); + joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, jpfuncname); + obj[funcName] = function(){ + var args = []; + + if((isNode)&&(!arguments.length)){ + var evt = null; + try{ + if(obj.ownerDocument){ + evt = obj.ownerDocument.parentWindow.event; + }else if(obj.documentElement){ + evt = o |
«
Return to OFBiz - Commits
|
1 view|%1 views
| Free forum by Nabble | Edit this page |