You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@myfaces.apache.org by we...@apache.org on 2006/01/27 00:58:20 UTC
svn commit: r372668 [6/16] - in
/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource:
./ src/ src/alg/ src/animation/ src/collections/ src/crypto/ src/data/
src/dnd/ src/event/ src/flash/ src/flash/flash6/ src...
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/html.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/html.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/html.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/html.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,987 @@
+/*
+ Copyright (c) 2004-2005, 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.html");
+dojo.require("dojo.dom");
+dojo.require("dojo.style");
+dojo.require("dojo.string");
+
+dojo.lang.mixin(dojo.html, dojo.dom);
+dojo.lang.mixin(dojo.html, dojo.style);
+
+// FIXME: we are going to assume that we can throw any and every rendering
+// engine into the IE 5.x box model. In Mozilla, we do this w/ CSS.
+// Need to investigate for KHTML and Opera
+
+dojo.html.clearSelection = function(){
+ try{
+ if(window["getSelection"]){
+ if(dojo.render.html.safari){
+ // pulled from WebCore/ecma/kjs_window.cpp, line 2536
+ window.getSelection().collapse();
+ }else{
+ window.getSelection().removeAllRanges();
+ }
+ }else if(document.selection){
+ if(document.selection.empty){
+ document.selection.empty();
+ }else if(document.selection.clear){
+ document.selection.clear();
+ }
+ }
+ return true;
+ }catch(e){
+ dojo.debug(e);
+ return false;
+ }
+}
+
+dojo.html.disableSelection = function(element){
+ element = dojo.byId(element)||dojo.html.body();
+ var h = dojo.render.html;
+
+ if(h.mozilla){
+ element.style.MozUserSelect = "none";
+ }else if(h.safari){
+ element.style.KhtmlUserSelect = "none";
+ }else if(h.ie){
+ element.unselectable = "on";
+ }else{
+ return false;
+ }
+ return true;
+}
+
+dojo.html.enableSelection = function(element){
+ element = dojo.byId(element)||dojo.html.body();
+
+ var h = dojo.render.html;
+ if(h.mozilla){
+ element.style.MozUserSelect = "";
+ }else if(h.safari){
+ element.style.KhtmlUserSelect = "";
+ }else if(h.ie){
+ element.unselectable = "off";
+ }else{
+ return false;
+ }
+ return true;
+}
+
+dojo.html.selectElement = function(element){
+ element = dojo.byId(element);
+ if(document.selection && dojo.html.body().createTextRange){ // IE
+ var range = dojo.html.body().createTextRange();
+ range.moveToElementText(element);
+ range.select();
+ }else if(window["getSelection"]){
+ var selection = window.getSelection();
+ // FIXME: does this work on Safari?
+ if(selection["selectAllChildren"]){ // Mozilla
+ selection.selectAllChildren(element);
+ }
+ }
+}
+
+dojo.html.isSelectionCollapsed = function(){
+ if(document["selection"]){ // IE
+ return document.selection.createRange().text == "";
+ }else if(window["getSelection"]){
+ var selection = window.getSelection();
+ if(dojo.lang.isString(selection)){ // Safari
+ return selection == "";
+ }else{ // Mozilla/W3
+ return selection.isCollapsed;
+ }
+ }
+}
+
+dojo.html.getEventTarget = function(evt){
+ if(!evt) { evt = window.event || {} };
+ if(evt.srcElement) {
+ return evt.srcElement;
+ } else if(evt.target) {
+ return evt.target;
+ }
+ return null;
+}
+
+// FIXME: should the next set of functions take an optional document to operate
+// on so as to be useful for getting this information from iframes?
+dojo.html.getScrollTop = function(){
+ return document.documentElement.scrollTop || dojo.html.body().scrollTop || 0;
+}
+
+dojo.html.getScrollLeft = function(){
+ return document.documentElement.scrollLeft || dojo.html.body().scrollLeft || 0;
+}
+
+dojo.html.getDocumentWidth = function(){
+ dojo.deprecated("dojo.html.getDocument* has been deprecated in favor of dojo.html.getViewport*");
+ return dojo.html.getViewportWidth();
+}
+
+dojo.html.getDocumentHeight = function(){
+ dojo.deprecated("dojo.html.getDocument* has been deprecated in favor of dojo.html.getViewport*");
+ return dojo.html.getViewportHeight();
+}
+
+dojo.html.getDocumentSize = function(){
+ dojo.deprecated("dojo.html.getDocument* has been deprecated in favor of dojo.html.getViewport*");
+ return dojo.html.getViewportSize();
+}
+
+dojo.html.getViewportWidth = function(){
+ var w = 0;
+
+ if(window.innerWidth){
+ w = window.innerWidth;
+ }
+
+ if(dojo.exists(document, "documentElement.clientWidth")){
+ // IE6 Strict
+ var w2 = document.documentElement.clientWidth;
+ // this lets us account for scrollbars
+ if(!w || w2 && w2 < w) {
+ w = w2;
+ }
+ return w;
+ }
+
+ if(document.body){
+ // IE
+ return document.body.clientWidth;
+ }
+
+ return 0;
+}
+
+dojo.html.getViewportHeight = function(){
+ if (window.innerHeight){
+ return window.innerHeight;
+ }
+
+ if (dojo.exists(document, "documentElement.clientHeight")){
+ // IE6 Strict
+ return document.documentElement.clientHeight;
+ }
+
+ if (document.body){
+ // IE
+ return document.body.clientHeight;
+ }
+
+ return 0;
+}
+
+dojo.html.getViewportSize = function(){
+ var ret = [dojo.html.getViewportWidth(), dojo.html.getViewportHeight()];
+ ret.w = ret[0];
+ ret.h = ret[1];
+ return ret;
+}
+
+dojo.html.getScrollOffset = function(){
+ var ret = [0, 0];
+
+ if(window.pageYOffset){
+ ret = [window.pageXOffset, window.pageYOffset];
+ }else if(dojo.exists(document, "documentElement.scrollTop")){
+ ret = [document.documentElement.scrollLeft, document.documentElement.scrollTop];
+ } else if(document.body){
+ ret = [document.body.scrollLeft, document.body.scrollTop];
+ }
+
+ ret.x = ret[0];
+ ret.y = ret[1];
+ return ret;
+}
+
+dojo.html.getParentOfType = function(node, type){
+ dojo.deprecated("dojo.html.getParentOfType has been deprecated in favor of dojo.html.getParentByType*");
+ return dojo.html.getParentByType(node, type);
+}
+
+dojo.html.getParentByType = function(node, type) {
+ var parent = dojo.byId(node);
+ type = type.toLowerCase();
+ while((parent)&&(parent.nodeName.toLowerCase()!=type)){
+ if(parent==(document["body"]||document["documentElement"])){
+ return null;
+ }
+ parent = parent.parentNode;
+ }
+ return parent;
+}
+
+// RAR: this function comes from nwidgets and is more-or-less unmodified.
+// We should probably look ant Burst and f(m)'s equivalents
+dojo.html.getAttribute = function(node, attr){
+ node = dojo.byId(node);
+ // FIXME: need to add support for attr-specific accessors
+ if((!node)||(!node.getAttribute)){
+ // if(attr !== 'nwType'){
+ // alert("getAttr of '" + attr + "' with bad node");
+ // }
+ return null;
+ }
+ var ta = typeof attr == 'string' ? attr : new String(attr);
+
+ // first try the approach most likely to succeed
+ var v = node.getAttribute(ta.toUpperCase());
+ if((v)&&(typeof v == 'string')&&(v!="")){ return v; }
+
+ // try returning the attributes value, if we couldn't get it as a string
+ if(v && v.value){ return v.value; }
+
+ // this should work on Opera 7, but it's a little on the crashy side
+ if((node.getAttributeNode)&&(node.getAttributeNode(ta))){
+ return (node.getAttributeNode(ta)).value;
+ }else if(node.getAttribute(ta)){
+ return node.getAttribute(ta);
+ }else if(node.getAttribute(ta.toLowerCase())){
+ return node.getAttribute(ta.toLowerCase());
+ }
+ return null;
+}
+
+/**
+ * Determines whether or not the specified node carries a value for the
+ * attribute in question.
+ */
+dojo.html.hasAttribute = function(node, attr){
+ node = dojo.byId(node);
+ return dojo.html.getAttribute(node, attr) ? true : false;
+}
+
+/**
+ * Returns the string value of the list of CSS classes currently assigned
+ * directly to the node in question. Returns an empty string if no class attribute
+ * is found;
+ */
+dojo.html.getClass = function(node){
+ node = dojo.byId(node);
+ if(!node){ return ""; }
+ var cs = "";
+ if(node.className){
+ cs = node.className;
+ }else if(dojo.html.hasAttribute(node, "class")){
+ cs = dojo.html.getAttribute(node, "class");
+ }
+ return dojo.string.trim(cs);
+}
+
+/**
+ * Returns an array of CSS classes currently assigned
+ * directly to the node in question. Returns an empty array if no classes
+ * are found;
+ */
+dojo.html.getClasses = function(node) {
+ node = dojo.byId(node);
+ var c = dojo.html.getClass(node);
+ return (c == "") ? [] : c.split(/\s+/g);
+}
+
+/**
+ * Returns whether or not the specified classname is a portion of the
+ * class list currently applied to the node. Does not cover cascaded
+ * styles, only classes directly applied to the node.
+ */
+dojo.html.hasClass = function(node, classname){
+ node = dojo.byId(node);
+ return dojo.lang.inArray(dojo.html.getClasses(node), classname);
+}
+
+/**
+ * Adds the specified class to the beginning of the class list on the
+ * passed node. This gives the specified class the highest precidence
+ * when style cascading is calculated for the node. Returns true or
+ * false; indicating success or failure of the operation, respectively.
+ */
+dojo.html.prependClass = function(node, classStr){
+ node = dojo.byId(node);
+ if(!node){ return false; }
+ classStr += " " + dojo.html.getClass(node);
+ return dojo.html.setClass(node, classStr);
+}
+
+/**
+ * Adds the specified class to the end of the class list on the
+ * passed &node;. Returns &true; or &false; indicating success or failure.
+ */
+dojo.html.addClass = function(node, classStr){
+ node = dojo.byId(node);
+ if (!node) { return false; }
+ if (dojo.html.hasClass(node, classStr)) {
+ return false;
+ }
+ classStr = dojo.string.trim(dojo.html.getClass(node) + " " + classStr);
+ return dojo.html.setClass(node, classStr);
+}
+
+/**
+ * Clobbers the existing list of classes for the node, replacing it with
+ * the list given in the 2nd argument. Returns true or false
+ * indicating success or failure.
+ */
+dojo.html.setClass = function(node, classStr){
+ node = dojo.byId(node);
+ if(!node){ return false; }
+ var cs = new String(classStr);
+ try{
+ if(typeof node.className == "string"){
+ node.className = cs;
+ }else if(node.setAttribute){
+ node.setAttribute("class", classStr);
+ node.className = cs;
+ }else{
+ return false;
+ }
+ }catch(e){
+ dojo.debug("dojo.html.setClass() failed", e);
+ }
+ return true;
+}
+
+/**
+ * Removes the className from the node;. Returns
+ * true or false indicating success or failure.
+ */
+dojo.html.removeClass = function(node, classStr, allowPartialMatches){
+ node = dojo.byId(node);
+ if(!node){ return false; }
+ var classStr = dojo.string.trim(new String(classStr));
+
+ try{
+ var cs = dojo.html.getClasses(node);
+ var nca = [];
+ if(allowPartialMatches){
+ for(var i = 0; i<cs.length; i++){
+ if(cs[i].indexOf(classStr) == -1){
+ nca.push(cs[i]);
+ }
+ }
+ }else{
+ for(var i=0; i<cs.length; i++){
+ if(cs[i] != classStr){
+ nca.push(cs[i]);
+ }
+ }
+ }
+ dojo.html.setClass(node, nca.join(" "));
+ }catch(e){
+ dojo.debug("dojo.html.removeClass() failed", e);
+ }
+
+ return true;
+}
+
+/**
+ * Replaces 'oldClass' and adds 'newClass' to node
+ */
+dojo.html.replaceClass = function(node, newClass, oldClass) {
+ node = dojo.byId(node);
+ dojo.html.removeClass(node, oldClass);
+ dojo.html.addClass(node, newClass);
+}
+
+// Enum type for getElementsByClass classMatchType arg:
+dojo.html.classMatchType = {
+ ContainsAll : 0, // all of the classes are part of the node's class (default)
+ ContainsAny : 1, // any of the classes are part of the node's class
+ IsOnly : 2 // only all of the classes are part of the node's class
+}
+
+
+/**
+ * Returns an array of nodes for the given classStr, children of a
+ * parent, and optionally of a certain nodeType
+ */
+dojo.html.getElementsByClass = function(classStr, parent, nodeType, classMatchType){
+ parent = dojo.byId(parent);
+ if(!parent){ parent = document; }
+ var classes = classStr.split(/\s+/g);
+ var nodes = [];
+ if( classMatchType != 1 && classMatchType != 2 ) classMatchType = 0; // make it enum
+ var reClass = new RegExp("(\\s|^)((" + classes.join(")|(") + "))(\\s|$)");
+
+ // FIXME: doesn't have correct parent support!
+ if(!nodeType){ nodeType = "*"; }
+ var candidateNodes = parent.getElementsByTagName(nodeType);
+
+ outer:
+ for(var i = 0; i < candidateNodes.length; i++) {
+ var node = candidateNodes[i];
+ var nodeClasses = dojo.html.getClasses(node);
+ if(nodeClasses.length == 0) { continue outer; }
+ var matches = 0;
+
+ for(var j = 0; j < nodeClasses.length; j++) {
+ if( reClass.test(nodeClasses[j]) ) {
+ if( classMatchType == dojo.html.classMatchType.ContainsAny ) {
+ nodes.push(node);
+ continue outer;
+ } else {
+ matches++;
+ }
+ } else {
+ if( classMatchType == dojo.html.classMatchType.IsOnly ) {
+ continue outer;
+ }
+ }
+ }
+
+ if( matches == classes.length ) {
+ if( classMatchType == dojo.html.classMatchType.IsOnly && matches == nodeClasses.length ) {
+ nodes.push(node);
+ } else if( classMatchType == dojo.html.classMatchType.ContainsAll ) {
+ nodes.push(node);
+ }
+ }
+ }
+
+ return nodes;
+}
+dojo.html.getElementsByClassName = dojo.html.getElementsByClass;
+
+/**
+ * Calculates the mouse's direction of gravity relative to the centre
+ * of the given node.
+ * <p>
+ * If you wanted to insert a node into a DOM tree based on the mouse
+ * position you might use the following code:
+ * <pre>
+ * if (gravity(node, e) & gravity.NORTH) { [insert before]; }
+ * else { [insert after]; }
+ * </pre>
+ *
+ * @param node The node
+ * @param e The event containing the mouse coordinates
+ * @return The directions, NORTH or SOUTH and EAST or WEST. These
+ * are properties of the function.
+ */
+dojo.html.gravity = function(node, e){
+ node = dojo.byId(node);
+ var mousex = e.pageX || e.clientX + dojo.html.body().scrollLeft;
+ var mousey = e.pageY || e.clientY + dojo.html.body().scrollTop;
+
+ with (dojo.html) {
+ var nodecenterx = getAbsoluteX(node) + (getInnerWidth(node) / 2);
+ var nodecentery = getAbsoluteY(node) + (getInnerHeight(node) / 2);
+ }
+
+ with (dojo.html.gravity) {
+ return ((mousex < nodecenterx ? WEST : EAST) |
+ (mousey < nodecentery ? NORTH : SOUTH));
+ }
+}
+
+dojo.html.gravity.NORTH = 1;
+dojo.html.gravity.SOUTH = 1 << 1;
+dojo.html.gravity.EAST = 1 << 2;
+dojo.html.gravity.WEST = 1 << 3;
+
+dojo.html.overElement = function(element, e){
+ element = dojo.byId(element);
+ var mousex = e.pageX || e.clientX + dojo.html.body().scrollLeft;
+ var mousey = e.pageY || e.clientY + dojo.html.body().scrollTop;
+
+ with(dojo.html){
+ var top = getAbsoluteY(element);
+ var bottom = top + getInnerHeight(element);
+ var left = getAbsoluteX(element);
+ var right = left + getInnerWidth(element);
+ }
+
+ return (mousex >= left && mousex <= right &&
+ mousey >= top && mousey <= bottom);
+}
+
+/**
+ * Attempts to return the text as it would be rendered, with the line breaks
+ * sorted out nicely. Unfinished.
+ */
+dojo.html.renderedTextContent = function(node){
+ node = dojo.byId(node);
+ 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
+ var display = "unknown";
+ try {
+ display = dojo.style.getStyle(node.childNodes[i], "display");
+ } catch(E) {}
+ switch (display) {
+ case "block": case "list-item": case "run-in":
+ case "table": case "table-row-group": case "table-header-group":
+ case "table-footer-group": case "table-row": case "table-column-group":
+ case "table-column": case "table-cell": case "table-caption":
+ // TODO: this shouldn't insert double spaces on aligning blocks
+ result += "\n";
+ result += dojo.html.renderedTextContent(node.childNodes[i]);
+ result += "\n";
+ break;
+
+ case "none": break;
+
+ default:
+ if(node.childNodes[i].tagName && node.childNodes[i].tagName.toLowerCase() == "br") {
+ result += "\n";
+ } else {
+ result += dojo.html.renderedTextContent(node.childNodes[i]);
+ }
+ break;
+ }
+ break;
+ case 3: // TEXT_NODE
+ case 2: // ATTRIBUTE_NODE
+ case 4: // CDATA_SECTION_NODE
+ var text = node.childNodes[i].nodeValue;
+ var textTransform = "unknown";
+ try {
+ textTransform = dojo.style.getStyle(node, "text-transform");
+ } catch(E) {}
+ switch (textTransform){
+ case "capitalize": text = dojo.string.capitalize(text); break;
+ case "uppercase": text = text.toUpperCase(); break;
+ case "lowercase": text = text.toLowerCase(); break;
+ default: break; // leave as is
+ }
+ // TODO: implement
+ switch (textTransform){
+ case "nowrap": break;
+ case "pre-wrap": break;
+ case "pre-line": break;
+ case "pre": break; // leave as is
+ default:
+ // remove whitespace and collapse first space
+ text = text.replace(/\s+/, " ");
+ if (/\s$/.test(result)) { text.replace(/^\s/, ""); }
+ break;
+ }
+ result += text;
+ break;
+ default:
+ break;
+ }
+ }
+ return result;
+}
+
+dojo.html.setActiveStyleSheet = function(title){
+ var i, a, main;
+ for(i=0; (a = document.getElementsByTagName("link")[i]); i++){
+ if(a.getAttribute("rel").indexOf("style") != -1 && a.getAttribute("title")){
+ a.disabled = true;
+ if (a.getAttribute("title") == title) { a.disabled = false; }
+ }
+ }
+}
+
+dojo.html.getActiveStyleSheet = function(){
+ var i, a;
+ // FIXME: getElementsByTagName returns a live collection. This seems like a
+ // bad key for iteration.
+ for(i=0; (a = document.getElementsByTagName("link")[i]); i++){
+ if (a.getAttribute("rel").indexOf("style") != -1 &&
+ a.getAttribute("title") && !a.disabled) { return a.getAttribute("title"); }
+ }
+ return null;
+}
+
+dojo.html.getPreferredStyleSheet = function(){
+ var i, a;
+ for(i=0; (a = document.getElementsByTagName("link")[i]); i++){
+ if(a.getAttribute("rel").indexOf("style") != -1
+ && a.getAttribute("rel").indexOf("alt") == -1
+ && a.getAttribute("title")) { return a.getAttribute("title"); }
+ }
+ return null;
+}
+
+dojo.html.body = function(){
+ return document.body || document.getElementsByTagName("body")[0];
+}
+
+dojo.html.createNodesFromText = function(txt, trim){
+ if(trim) { txt = dojo.string.trim(txt); }
+
+ var tn = document.createElement("div");
+ // tn.style.display = "none";
+ tn.style.visibility= "hidden";
+ document.body.appendChild(tn);
+ var tableType = "none";
+ if((/^<t[dh][\s\r\n>]/i).test(dojo.string.trimStart(txt))) {
+ txt = "<table><tbody><tr>" + txt + "</tr></tbody></table>";
+ tableType = "cell";
+ } else if((/^<tr[\s\r\n>]/i).test(dojo.string.trimStart(txt))) {
+ txt = "<table><tbody>" + txt + "</tbody></table>";
+ tableType = "row";
+ } else if((/^<(thead|tbody|tfoot)[\s\r\n>]/i).test(dojo.string.trimStart(txt))) {
+ txt = "<table>" + txt + "</table>";
+ tableType = "section";
+ }
+ tn.innerHTML = txt;
+ tn.normalize();
+
+ var parent = null;
+ switch(tableType) {
+ case "cell":
+ parent = tn.getElementsByTagName("tr")[0];
+ break;
+ case "row":
+ parent = tn.getElementsByTagName("tbody")[0];
+ break;
+ case "section":
+ parent = tn.getElementsByTagName("table")[0];
+ break;
+ default:
+ parent = tn;
+ break;
+ }
+
+ /* this doesn't make much sense, I'm assuming it just meant trim() so wrap was replaced with trim
+ if(wrap){
+ var ret = [];
+ // start hack
+ var fc = tn.firstChild;
+ ret[0] = ((fc.nodeValue == " ")||(fc.nodeValue == "\t")) ? fc.nextSibling : fc;
+ // end hack
+ // tn.style.display = "none";
+ document.body.removeChild(tn);
+ return ret;
+ }
+ */
+ var nodes = [];
+ for(var x=0; x<parent.childNodes.length; x++){
+ nodes.push(parent.childNodes[x].cloneNode(true));
+ }
+ tn.style.display = "none"; // FIXME: why do we do this?
+ document.body.removeChild(tn);
+ return nodes;
+}
+
+// FIXME: this should be removed after 0.2 release
+if(!dojo.evalObjPath("dojo.dom.createNodesFromText")){
+ dojo.dom.createNodesFromText = function() {
+ dojo.deprecated("dojo.dom.createNodesFromText", "use dojo.html.createNodesFromText instead");
+ return dojo.html.createNodesFromText.apply(dojo.html, arguments);
+ }
+}
+
+dojo.html.isVisible = function(node){
+ node = dojo.byId(node);
+ // FIXME: this should also look at visibility!
+ return dojo.style.getComputedStyle(node||this.domNode, "display") != "none";
+}
+
+dojo.html.show = function(node){
+ node = dojo.byId(node);
+ if(node.style){
+ node.style.display = dojo.lang.inArray(['tr', 'td', 'th'], node.tagName.toLowerCase()) ? "" : "block";
+ }
+}
+
+dojo.html.hide = function(node){
+ node = dojo.byId(node);
+ if(node.style){
+ node.style.display = "none";
+ }
+}
+
+dojo.html.toggleVisible = function(node) {
+ if(dojo.html.isVisible(node)) {
+ dojo.html.hide(node);
+ return false;
+ } else {
+ dojo.html.show(node);
+ return true;
+ }
+}
+
+/**
+ * Like dojo.dom.isTag, except case-insensitive
+**/
+dojo.html.isTag = function(node /* ... */) {
+ node = dojo.byId(node);
+ if(node && node.tagName) {
+ var arr = dojo.lang.map(dojo.lang.toArray(arguments, 1),
+ function(a) { return String(a).toLowerCase(); });
+ return arr[ dojo.lang.find(node.tagName.toLowerCase(), arr) ] || "";
+ }
+ return "";
+}
+
+// in: coordinate array [x,y,w,h] or dom node
+// return: coordinate array
+dojo.html.toCoordinateArray = function(coords, includeScroll) {
+ if(dojo.lang.isArray(coords)){
+ // coords is already an array (of format [x,y,w,h]), just return it
+ while ( coords.length < 4 ) { coords.push(0); }
+ while ( coords.length > 4 ) { coords.pop(); }
+ var ret = coords;
+ } else {
+ // coords is an dom object (or dom object id); return it's coordinates
+ var node = dojo.byId(coords);
+ var ret = [
+ dojo.html.getAbsoluteX(node, includeScroll),
+ dojo.html.getAbsoluteY(node, includeScroll),
+ dojo.html.getInnerWidth(node),
+ dojo.html.getInnerHeight(node)
+ ];
+ }
+ ret.x = ret[0];
+ ret.y = ret[1];
+ ret.w = ret[2];
+ ret.h = ret[3];
+ return ret;
+};
+
+/* TODO: merge placeOnScreen and placeOnScreenPoint to make 1 function that allows you
+ * to define which corner(s) you want to bind to. Something like so:
+ *
+ * kes(node, desiredX, desiredY, "TR")
+ * kes(node, [desiredX, desiredY], ["TR", "BL"])
+ *
+ * TODO: make this function have variable call sigs
+ *
+ * kes(node, ptArray, cornerArray, padding, hasScroll)
+ * kes(node, ptX, ptY, cornerA, cornerB, cornerC, paddingArray, hasScroll)
+ */
+
+/**
+ * Keeps 'node' in the visible area of the screen while trying to
+ * place closest to desiredX, desiredY. The input coordinates are
+ * expected to be the desired screen position, not accounting for
+ * scrolling. If you already accounted for scrolling, set 'hasScroll'
+ * to true. Set padding to either a number or array for [paddingX, paddingY]
+ * to put some buffer around the element you want to position.
+ * NOTE: node is assumed to be absolutely or relatively positioned.
+ *
+ * Alternate call sig:
+ * placeOnScreen(node, [x, y], padding, hasScroll)
+ *
+ * Examples:
+ * placeOnScreen(node, 100, 200)
+ * placeOnScreen("myId", [800, 623], 5)
+ * placeOnScreen(node, 234, 3284, [2, 5], true)
+ */
+dojo.html.placeOnScreen = function(node, desiredX, desiredY, padding, hasScroll) {
+ if(dojo.lang.isArray(desiredX)) {
+ hasScroll = padding;
+ padding = desiredY;
+ desiredY = desiredX[1];
+ desiredX = desiredX[0];
+ }
+
+ if(!isNaN(padding)) {
+ padding = [Number(padding), Number(padding)];
+ } else if(!dojo.lang.isArray(padding)) {
+ padding = [0, 0];
+ }
+
+ var scroll = dojo.html.getScrollOffset();
+ var view = dojo.html.getViewportSize();
+
+ node = dojo.byId(node);
+ var w = node.offsetWidth + padding[0];
+ var h = node.offsetHeight + padding[1];
+
+ if(hasScroll) {
+ desiredX -= scroll.x;
+ desiredY -= scroll.y;
+ }
+
+ var x = desiredX + w;
+ if(x > view.w) {
+ x = view.w - w;
+ } else {
+ x = desiredX;
+ }
+ x = Math.max(padding[0], x) + scroll.x;
+
+ var y = desiredY + h;
+ if(y > view.h) {
+ y = view.h - h;
+ } else {
+ y = desiredY;
+ }
+ y = Math.max(padding[1], y) + scroll.y;
+
+ node.style.left = x + "px";
+ node.style.top = y + "px";
+
+ var ret = [x, y];
+ ret.x = x;
+ ret.y = y;
+ return ret;
+}
+
+/**
+ * Like placeOnScreenPoint except that it attempts to keep one of the node's
+ * corners at desiredX, desiredY. Also note that padding is only taken into
+ * account if none of the corners can be kept and thus placeOnScreenPoint falls
+ * back to placeOnScreen to place the node.
+ *
+ * Examples placing node at mouse position (where e = [Mouse event]):
+ * placeOnScreenPoint(node, e.clientX, e.clientY);
+ */
+dojo.html.placeOnScreenPoint = function(node, desiredX, desiredY, padding, hasScroll) {
+ if(dojo.lang.isArray(desiredX)) {
+ hasScroll = padding;
+ padding = desiredY;
+ desiredY = desiredX[1];
+ desiredX = desiredX[0];
+ }
+
+ var scroll = dojo.html.getScrollOffset();
+ var view = dojo.html.getViewportSize();
+
+ node = dojo.byId(node);
+ var w = node.offsetWidth;
+ var h = node.offsetHeight;
+
+ if(hasScroll) {
+ desiredX -= scroll.x;
+ desiredY -= scroll.y;
+ }
+
+ var x = -1, y = -1;
+ //dojo.debug(desiredX + w, "<=", view.w, "&&", desiredY + h, "<=", view.h);
+ if(desiredX + w <= view.w && desiredY + h <= view.h) { // TL
+ x = desiredX;
+ y = desiredY;
+ //dojo.debug("TL", x, y);
+ }
+
+ //dojo.debug(desiredX, "<=", view.w, "&&", desiredY + h, "<=", view.h);
+ if((x < 0 || y < 0) && desiredX <= view.w && desiredY + h <= view.h) { // TR
+ x = desiredX - w;
+ y = desiredY;
+ //dojo.debug("TR", x, y);
+ }
+
+ //dojo.debug(desiredX + w, "<=", view.w, "&&", desiredY, "<=", view.h);
+ if((x < 0 || y < 0) && desiredX + w <= view.w && desiredY <= view.h) { // BL
+ x = desiredX;
+ y = desiredY - h;
+ //dojo.debug("BL", x, y);
+ }
+
+ //dojo.debug(desiredX, "<=", view.w, "&&", desiredY, "<=", view.h);
+ if((x < 0 || y < 0) && desiredX <= view.w && desiredY <= view.h) { // BR
+ x = desiredX - w;
+ y = desiredY - h;
+ //dojo.debug("BR", x, y);
+ }
+
+ if(x < 0 || y < 0 || (x + w > view.w) || (y + h > view.h)) {
+ return dojo.html.placeOnScreen(node, desiredX, desiredY, padding, hasScroll);
+ }
+
+ x += scroll.x;
+ y += scroll.y;
+
+ node.style.left = x + "px";
+ node.style.top = y + "px";
+
+ var ret = [x, y];
+ ret.x = x;
+ ret.y = y;
+ return ret;
+}
+
+/**
+ * For IE z-index schenanigans
+ * See Dialog widget for sample use
+ */
+dojo.html.BackgroundIframe = function() {
+ if(this.ie) {
+ this.iframe = document.createElement("<iframe frameborder='0' src='about:blank'>");
+ var s = this.iframe.style;
+ s.position = "absolute";
+ s.left = s.top = "0px";
+ s.zIndex = 2;
+ s.display = "none";
+ dojo.style.setOpacity(this.iframe, 0.0);
+ dojo.html.body().appendChild(this.iframe);
+ } else {
+ this.enabled = false;
+ }
+}
+dojo.lang.extend(dojo.html.BackgroundIframe, {
+ ie: dojo.render.html.ie,
+ enabled: true,
+ visibile: false,
+ iframe: null,
+ sizeNode: null,
+ sizeCoords: null,
+
+ size: function(node /* or coords */) {
+ if(!this.ie || !this.enabled) { return; }
+
+ if(dojo.dom.isNode(node)) {
+ this.sizeNode = node;
+ } else if(arguments.length > 0) {
+ this.sizeNode = null;
+ this.sizeCoords = node;
+ }
+ this.update();
+ },
+
+ update: function() {
+ if(!this.ie || !this.enabled) { return; }
+
+ if(this.sizeNode) {
+ this.sizeCoords = dojo.html.toCoordinateArray(this.sizeNode, true);
+ } else if(this.sizeCoords) {
+ this.sizeCoords = dojo.html.toCoordinateArray(this.sizeCoords, true);
+ } else {
+ return;
+ }
+
+ var s = this.iframe.style;
+ var dims = this.sizeCoords;
+ s.width = dims.w + "px";
+ s.height = dims.h + "px";
+ s.left = dims.x + "px";
+ s.top = dims.y + "px";
+ },
+
+ setZIndex: function(node /* or number */) {
+ if(!this.ie || !this.enabled) { return; }
+
+ if(dojo.dom.isNode(node)) {
+ this.iframe.zIndex = dojo.html.getStyle(node, "z-index") - 1;
+ } else if(!isNaN(node)) {
+ this.iframe.zIndex = node;
+ }
+ },
+
+ show: function(node /* or coords */) {
+ if(!this.ie || !this.enabled) { return; }
+
+ this.size(node);
+ this.iframe.style.display = "block";
+ },
+
+ hide: function() {
+ if(!this.ie) { return; }
+ var s = this.iframe.style;
+ s.display = "none";
+ s.width = s.height = "1px";
+ },
+
+ remove: function() {
+ dojo.dom.removeNode(this.iframe);
+ }
+});
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/iCalendar.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/iCalendar.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/iCalendar.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/iCalendar.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,264 @@
+/*
+ Copyright (c) 2004-2005, 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.iCalendar");
+dojo.provide("dojo.iCalendar.Component");
+dojo.provide("dojo.iCalendar.Property");
+dojo.require("dojo.text.textDirectory");
+dojo.require("dojo.date");
+// iCalendar support adapted from Paul Sowden's iCalendar work
+
+dojo.iCalendar = function (/* string */calbody) {
+ // summary
+ // Main iCalendar Object.
+ // In actuality it is a VCALENDAR component.
+
+ // ugly ugly way to inherit
+ for (prop in dojo.iCalendar.Component.prototype) {
+ this[prop] = dojo.iCalendar.Component.prototype[prop];
+ }
+
+ dojo.iCalendar.Component.call(this, "VCALENDAR", calbody);
+}
+
+dojo.lang.extend(dojo.iCalendar, {
+ getEvents: function (/* string */ startDate, /* string */ endDate) {
+ // summary
+ // retrieve an array of events that fall between startDate and endDate
+
+ var evts = [];
+
+ if (dojo.lang.isString(startDate)) {
+ var start = dojo.date.fromIso8601(startDate);
+ } else {
+ start = startDate;
+ }
+
+ if (dojo.lang.isString(endDate)) {
+ var end = dojo.date.fromIso8601(endDate);
+ } else {
+ end = endDate;
+ }
+
+ //dojo.debug("getting events between " + start+ " and " + end);
+ //dojo.debug("Total events to search: " + this.components.length.toString());
+ for (var x=0; x<this.components.length; x++) {
+ if (this.components[x].name == "VEVENT") {
+ evtStart = dojo.date.fromIso8601(this.components[x].dtstart.value);
+ evtEnd= dojo.date.fromIso8601(this.components[x].dtend.value);
+
+ if (((evtStart >= start) && (evtStart <= end)) || ((evtStart <= end) && (evtEnd >= start))) {
+ //dojo.debug("Outside of range: " + evtStart + " " + evtEnd);
+ evts.push(this.components[x]);
+ }
+ }
+ }
+ return /* array */ evts;
+ }
+});
+
+
+dojo.iCalendar.fromText = function (/* string */text) {
+ // summary
+ // Parse text of an iCalendar and return an array of iCalendar objects
+
+ var properties = dojo.textDirectoryTokeniser.tokenise(text);
+ var calendars = [];
+
+ for (var i = 0, begun = false; i < properties.length; i++) {
+ var prop = properties[i];
+ //dojo.debug("Property Name: " + prop.name + " = " + prop.value);
+ if (!begun) {
+ if (prop.name == 'BEGIN' && prop.value == 'VCALENDAR') {
+ begun = true;
+ var calbody = [];
+ }
+ } else if (prop.name == 'END' && prop.value == 'VCALENDAR') {
+ calendars.push(new dojo.iCalendar(calbody));
+ begun = false;
+ } else {
+ calbody.push(prop);
+ }
+ }
+ return /* array */calendars;
+}
+
+dojo.iCalendar.Component = function (/* string */ name, /* string */ body) {
+ // summary
+ // A component is the basic container of all this stuff. A VCALENDAR is a component that
+ // holds VEVENT Componenets for example. A particular component is made up of its own
+ // properties as well as other components that it holds.
+
+ this.name = name;
+ this.properties = [];
+ this.components = [];
+
+ for (var i = 0, context = ''; i < body.length; i++) {
+ if (context == '') {
+ if (body[i].name == 'BEGIN') {
+ context = body[i].value;
+ var childprops = [];
+ } else {
+ this.addProperty(new dojo.iCalendar.Property(body[i]));
+ }
+ } else if (body[i].name == 'END' && body[i].value == context) {
+ this.addComponent(new dojo.iCalendar.Component(context, childprops));
+ context = '';
+ } else {
+ childprops.push(body[i]);
+ }
+ }
+}
+
+dojo.lang.extend(dojo.iCalendar.Component, {
+
+ addProperty: function (prop) {
+ // summary
+ // push a nuew propertie onto a component.
+ this.properties.push(prop);
+ this[prop.name.toLowerCase()] = prop;
+ },
+
+ addComponent: function (prop) {
+ // summary
+ // add a component to this components list of children.
+ this.components.push(prop);
+ },
+
+
+ toString: function () {
+ // summary
+ // output a string representation of this component.
+ return "[iCalendar.Component; " + this.name + ", " + this.properties.length +
+ " properties, " + this.components.length + " components]";
+ }
+});
+
+dojo.iCalendar.Property = function (prop) {
+ // summary
+ // A single property of a component.
+
+ // unpack the values
+ this.name = prop.name;
+ this.group = prop.group;
+ this.params = prop.params;
+ this.value = prop.value;
+}
+
+dojo.lang.extend(dojo.iCalendar.Property, {
+ toString: function () {
+ // summary
+ // output a string reprensentation of this component.
+ return "[iCalenday.Property; " + this.name + ": " + this.value + "]";
+ }
+});
+
+/*
+ * Here is a whole load of stuff that could go towards making this
+ * class validating, but right now I'm not caring
+ */
+
+/*
+
+
+dojo.iCalendar.VEVENT = function () {}
+
+dojo.iCalendar.VEVENT.prototype.addProperty = function (prop) {
+
+}
+
+dojo.iCalendar.VTODO = function () {}
+dojo.iCalendar.VJOURNAL = function () {}
+dojo.iCalendar.VFREEBUSY = function () {}
+dojo.iCalendar.VTIMEZONE = function () {}
+
+var _ = function (n, oc, req) {
+ return {name: n, required: (req) ? true : false,
+ occurance: (oc == '*' || !oc) ? -1 : oc}
+}
+
+var VEVENT = [
+ // these can occur once only
+ _("class", 1), _("created", 1), _("description", 1), _("dtstart", 1),
+ _("geo", 1), _("last-mod", 1), _("location", 1), _("organizer", 1),
+ _("priority", 1), _("dtstamp", 1), _("seq", 1), _("status", 1),
+ _("summary", 1), _("transp", 1), _("uid", 1), _("url", 1), _("recurid", 1),
+ // these two are exclusive
+ [_("dtend", 1), _("duration", 1)],
+ // these can occur many times over
+ _("attach"), _("attendee"), _("categories"), _("comment"), _("contact"),
+ _("exdate"), _("exrule"), _("rstatus"), _("related"), _("resources"),
+ _("rdate"), _("rrule")
+]
+
+
+var VTODO = [
+ // these can occur once only
+ _("class", 1), _("completed", 1), _("created", 1), _("description", 1),
+ _("dtstart", 1), _("geo", 1), _("last-mod", 1), _("location", 1),
+ _("organizer", 1), _("percent", 1), _("priority", 1), _("dtstamp", 1),
+ _("seq", 1), _("status", 1), _("summary", 1), _("uid", 1), _("url", 1),
+ _("recurid", 1),
+ // these two are exclusive
+ [_("due", 1), _("duration", 1)],
+ // these can occur many times over
+ _("attach"), _("attendee"), _("categories"), _("comment"), _("contact"),
+ _("exdate"), _("exrule"), _("rstatus"), _("related"), _("resources"),
+ _("rdate"), _("rrule")
+]
+
+var VJOURNAL = [
+ // these can occur once only
+ _("class", 1), _("created", 1), _("description", 1), _("dtstart", 1),
+ _("last-mod", 1), _("organizer", 1), _("dtstamp", 1), _("seq", 1),
+ _("status", 1), _("summary", 1), _("uid", 1), _("url", 1), _("recurid", 1),
+ // these can occur many times over
+ _("attach"), _("attendee"), _("categories"), _("comment"), _("contact"),
+ _("exdate"), _("exrule"), _("related"), _("rstatus"), _("rdate"), _("rrule")
+]
+
+var VFREEBUSY = [
+ // these can occur once only
+ _("contact"), _("dtstart", 1), _("dtend"), _("duration"),
+ _("organizer", 1), _("dtstamp", 1), _("uid", 1), _("url", 1),
+ // these can occur many times over
+ _("attendee"), _("comment"), _("freebusy"), _("rstatus")
+]
+
+var VTIMEZONE = [
+ _("tzid", 1, true), _("last-mod", 1), _("tzurl", 1)
+
+ // one of 'standardc' or 'daylightc' must occur
+ // and each may occur more than once.
+]
+
+var STANDARD = [
+ _("dtstart", 1, true), _("tzoffsett", 1, true), _("tzoffsetfrom", 1, true),
+ _("comment"), _("rdate"), _("rrule"), _("tzname")];
+var daylight = standard;
+
+var VALARM = [
+
+[_("action", 1, true), _("trigger", 1, true), [_("duration", 1), _("repeat", 1)],
+_("attach", 1)];
+
+[_("action", 1, true), _("description", 1, true), _("trigger", 1, true),
+[_("duration", 1), _("repeat", 1)]];
+
+[_("action", 1, true), _("description", 1, true), _("trigger", 1, true),
+_("summary", 1, true), _("attendee", "*", true),
+[_("duration", 1), _("repeat", 1)],
+_("attach", 1)];
+
+[_("action", 1, true), _("attach", 1, true), _("trigger", 1, true),
+[_("duration", 1), _("repeat", 1)],
+_("description", 1)];
+
+]*/
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,317 @@
+/*
+ Copyright (c) 2004-2005, 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.io.IO");
+dojo.require("dojo.string");
+
+/******************************************************************************
+ * Notes about dojo.io design:
+ *
+ * The dojo.io.* package has the unenviable task of making a lot of different
+ * types of I/O feel natural, despite a universal lack of good (or even
+ * reasonable!) I/O capability in the host environment. So lets pin this down
+ * a little bit further.
+ *
+ * Rhino:
+ * perhaps the best situation anywhere. Access to Java classes allows you
+ * to do anything one might want in terms of I/O, both synchronously and
+ * async. Can open TCP sockets and perform low-latency client/server
+ * interactions. HTTP transport is available through Java HTTP client and
+ * server classes. Wish it were always this easy.
+ *
+ * xpcshell:
+ * XPCOM for I/O. A cluster-fuck to be sure.
+ *
+ * spidermonkey:
+ * S.O.L.
+ *
+ * Browsers:
+ * Browsers generally do not provide any useable filesystem access. We are
+ * therefore limited to HTTP for moving information to and from Dojo
+ * instances living in a browser.
+ *
+ * XMLHTTP:
+ * Sync or async, allows reading of arbitrary text files (including
+ * JS, which can then be eval()'d), writing requires server
+ * cooperation and is limited to HTTP mechanisms (POST and GET).
+ *
+ * <iframe> hacks:
+ * iframe document hacks allow browsers to communicate asynchronously
+ * with a server via HTTP POST and GET operations. With significant
+ * effort and server cooperation, low-latency data transit between
+ * client and server can be acheived via iframe mechanisms (repubsub).
+ *
+ * SVG:
+ * Adobe's SVG viewer implements helpful primitives for XML-based
+ * requests, but receipt of arbitrary text data seems unlikely w/o
+ * <![CDATA[]]> sections.
+ *
+ *
+ * A discussion between Dylan, Mark, Tom, and Alex helped to lay down a lot
+ * the IO API interface. A transcript of it can be found at:
+ * http://dojotoolkit.org/viewcvs/viewcvs.py/documents/irc/irc_io_api_log.txt?rev=307&view=auto
+ *
+ * Also referenced in the design of the API was the DOM 3 L&S spec:
+ * http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save.html
+ ******************************************************************************/
+
+// a map of the available transport options. Transports should add themselves
+// by calling add(name)
+dojo.io.transports = [];
+dojo.io.hdlrFuncNames = [ "load", "error" ]; // we're omitting a progress() event for now
+
+dojo.io.Request = function(url, mimetype, transport, changeUrl){
+ if((arguments.length == 1)&&(arguments[0].constructor == Object)){
+ this.fromKwArgs(arguments[0]);
+ }else{
+ this.url = url;
+ if(mimetype){ this.mimetype = mimetype; }
+ if(transport){ this.transport = transport; }
+ if(arguments.length >= 4){ this.changeUrl = changeUrl; }
+ }
+}
+
+dojo.lang.extend(dojo.io.Request, {
+
+ /** The URL to hit */
+ url: "",
+
+ /** The mime type used to interrpret the response body */
+ mimetype: "text/plain",
+
+ /** The HTTP method to use */
+ method: "GET",
+
+ /** An Object containing key-value pairs to be included with the request */
+ content: undefined, // Object
+
+ /** The transport medium to use */
+ transport: undefined, // String
+
+ /** If defined the URL of the page is physically changed */
+ changeUrl: undefined, // String
+
+ /** A form node to use in the request */
+ formNode: undefined, // HTMLFormElement
+
+ /** Whether the request should be made synchronously */
+ sync: false,
+
+ bindSuccess: false,
+
+ /** Cache/look for the request in the cache before attempting to request?
+ * NOTE: this isn't a browser cache, this is internal and would only cache in-page
+ */
+ useCache: false,
+
+ /** Prevent the browser from caching this by adding a query string argument to the URL */
+ preventCache: false,
+
+ // events stuff
+ load: function(type, data, evt){ },
+ error: function(type, error){ },
+ handle: function(){ },
+
+ // the abort method needs to be filled in by the transport that accepts the
+ // bind() request
+ abort: function(){ },
+
+ // backButton: function(){ },
+ // forwardButton: function(){ },
+
+ fromKwArgs: function(kwArgs){
+ // normalize args
+ if(kwArgs["url"]){ kwArgs.url = kwArgs.url.toString(); }
+ if(!kwArgs["method"] && kwArgs["formNode"] && kwArgs["formNode"].method) {
+ kwArgs.method = kwArgs["formNode"].method;
+ }
+
+ // backwards compatibility
+ if(!kwArgs["handle"] && kwArgs["handler"]){ kwArgs.handle = kwArgs.handler; }
+ if(!kwArgs["load"] && kwArgs["loaded"]){ kwArgs.load = kwArgs.loaded; }
+ if(!kwArgs["changeUrl"] && kwArgs["changeURL"]) { kwArgs.changeUrl = kwArgs.changeURL; }
+
+ // encoding fun!
+ kwArgs.encoding = dojo.lang.firstValued(kwArgs["encoding"], djConfig["bindEncoding"], "");
+
+ kwArgs.sendTransport = dojo.lang.firstValued(kwArgs["sendTransport"], djConfig["ioSendTransport"], true);
+
+ var isFunction = dojo.lang.isFunction;
+ for(var x=0; x<dojo.io.hdlrFuncNames.length; x++){
+ var fn = dojo.io.hdlrFuncNames[x];
+ if(isFunction(kwArgs[fn])){ continue; }
+ if(isFunction(kwArgs["handle"])){
+ kwArgs[fn] = kwArgs.handle;
+ }
+ // handler is aliased above, shouldn't need this check
+ /* else if(dojo.lang.isObject(kwArgs.handler)){
+ if(isFunction(kwArgs.handler[fn])){
+ kwArgs[fn] = kwArgs.handler[fn]||kwArgs.handler["handle"]||function(){};
+ }
+ }*/
+ }
+ dojo.lang.mixin(this, kwArgs);
+ }
+
+});
+
+dojo.io.Error = function(msg, type, num){
+ this.message = msg;
+ this.type = type || "unknown"; // must be one of "io", "parse", "unknown"
+ this.number = num || 0; // per-substrate error number, not normalized
+}
+
+dojo.io.transports.addTransport = function(name){
+ this.push(name);
+ // FIXME: do we need to handle things that aren't direct children of the
+ // dojo.io namespace? (say, dojo.io.foo.fooTransport?)
+ this[name] = dojo.io[name];
+}
+
+// binding interface, the various implementations register their capabilities
+// and the bind() method dispatches
+dojo.io.bind = function(request){
+ // if the request asks for a particular implementation, use it
+ if(!(request instanceof dojo.io.Request)){
+ try{
+ request = new dojo.io.Request(request);
+ }catch(e){ dojo.debug(e); }
+ }
+ var tsName = "";
+ if(request["transport"]){
+ tsName = request["transport"];
+ // FIXME: it would be good to call the error handler, although we'd
+ // need to use setTimeout or similar to accomplish this and we can't
+ // garuntee that this facility is available.
+ if(!this[tsName]){ return request; }
+ }else{
+ // otherwise we do our best to auto-detect what available transports
+ // will handle
+ for(var x=0; x<dojo.io.transports.length; x++){
+ var tmp = dojo.io.transports[x];
+ if((this[tmp])&&(this[tmp].canHandle(request))){
+ tsName = tmp;
+ }
+ }
+ if(tsName == ""){ return request; }
+ }
+ this[tsName].bind(request);
+ request.bindSuccess = true;
+ return request;
+}
+
+dojo.io.queueBind = function(request){
+ if(!(request instanceof dojo.io.Request)){
+ try{
+ request = new dojo.io.Request(request);
+ }catch(e){ dojo.debug(e); }
+ }
+
+ // make sure we get called if/when we get a response
+ var oldLoad = request.load;
+ request.load = function(){
+ dojo.io._queueBindInFlight = false;
+ var ret = oldLoad.apply(this, arguments);
+ dojo.io._dispatchNextQueueBind();
+ return ret;
+ }
+
+ var oldErr = request.error;
+ request.error = function(){
+ dojo.io._queueBindInFlight = false;
+ var ret = oldErr.apply(this, arguments);
+ dojo.io._dispatchNextQueueBind();
+ return ret;
+ }
+
+ dojo.io._bindQueue.push(request);
+ dojo.io._dispatchNextQueueBind();
+ return request;
+}
+
+dojo.io._dispatchNextQueueBind = function(){
+ if(!dojo.io._queueBindInFlight){
+ dojo.io._queueBindInFlight = true;
+ dojo.io.bind(dojo.io._bindQueue.shift());
+ }
+}
+dojo.io._bindQueue = [];
+dojo.io._queueBindInFlight = false;
+
+dojo.io.argsFromMap = function(map, encoding){
+ var control = new Object();
+ var mapStr = "";
+ var enc = /utf/i.test(encoding||"") ? encodeURIComponent : dojo.string.encodeAscii;
+ for(var x in map){
+ if(!control[x]){
+ mapStr+= enc(x)+"="+enc(map[x])+"&";
+ }
+ }
+
+ return mapStr;
+}
+
+/*
+dojo.io.sampleTranport = new function(){
+ this.canHandle = function(kwArgs){
+ // canHandle just tells dojo.io.bind() if this is a good transport to
+ // use for the particular type of request.
+ if(
+ (
+ (kwArgs["mimetype"] == "text/plain") ||
+ (kwArgs["mimetype"] == "text/html") ||
+ (kwArgs["mimetype"] == "text/javascript")
+ )&&(
+ (kwArgs["method"] == "get") ||
+ ( (kwArgs["method"] == "post") && (!kwArgs["formNode"]) )
+ )
+ ){
+ return true;
+ }
+
+ return false;
+ }
+
+ this.bind = function(kwArgs){
+ var hdlrObj = {};
+
+ // set up a handler object
+ for(var x=0; x<dojo.io.hdlrFuncNames.length; x++){
+ var fn = dojo.io.hdlrFuncNames[x];
+ if(typeof kwArgs.handler == "object"){
+ if(typeof kwArgs.handler[fn] == "function"){
+ hdlrObj[fn] = kwArgs.handler[fn]||kwArgs.handler["handle"];
+ }
+ }else if(typeof kwArgs[fn] == "function"){
+ hdlrObj[fn] = kwArgs[fn];
+ }else{
+ hdlrObj[fn] = kwArgs["handle"]||function(){};
+ }
+ }
+
+ // build a handler function that calls back to the handler obj
+ var hdlrFunc = function(evt){
+ if(evt.type == "onload"){
+ hdlrObj.load("load", evt.data, evt);
+ }else if(evt.type == "onerr"){
+ var errObj = new dojo.io.Error("sampleTransport Error: "+evt.msg);
+ hdlrObj.error("error", errObj);
+ }
+ }
+
+ // the sample transport would attach the hdlrFunc() when sending the
+ // request down the pipe at this point
+ var tgtURL = kwArgs.url+"?"+dojo.io.argsFromMap(kwArgs.content);
+ // sampleTransport.sendRequest(tgtURL, hdlrFunc);
+ }
+
+ dojo.io.transports.addTransport("sampleTranport");
+}
+*/
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io/BrowserIO.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io/BrowserIO.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io/BrowserIO.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io/BrowserIO.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,623 @@
+/*
+ Copyright (c) 2004-2005, 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.io.BrowserIO");
+
+dojo.require("dojo.io");
+dojo.require("dojo.lang");
+dojo.require("dojo.dom");
+
+try {
+ if((!djConfig["preventBackButtonFix"])&&(!dojo.hostenv.post_load_)){
+ document.write("<iframe style='border: 0px; width: 1px; height: 1px; position: absolute; bottom: 0px; right: 0px; visibility: visible;' name='djhistory' id='djhistory' src='"+(dojo.hostenv.getBaseScriptUri()+'iframe_history.html')+"'></iframe>");
+ }
+}catch(e){/* squelch */}
+
+dojo.io.checkChildrenForFile = function(node){
+ var hasFile = false;
+ var inputs = node.getElementsByTagName("input");
+ dojo.lang.forEach(inputs, function(input){
+ if(hasFile){ return; }
+ if(input.getAttribute("type")=="file"){
+ hasFile = true;
+ }
+ });
+ return hasFile;
+}
+
+dojo.io.formHasFile = function(formNode){
+ return dojo.io.checkChildrenForFile(formNode);
+}
+
+// TODO: Move to htmlUtils
+dojo.io.encodeForm = function(formNode, encoding){
+ if((!formNode)||(!formNode.tagName)||(!formNode.tagName.toLowerCase() == "form")){
+ dojo.raise("Attempted to encode a non-form element.");
+ }
+ var enc = /utf/i.test(encoding||"") ? encodeURIComponent : dojo.string.encodeAscii;
+ var values = [];
+
+ for(var i = 0; i < formNode.elements.length; i++){
+ var elm = formNode.elements[i];
+ if(elm.disabled || elm.tagName.toLowerCase() == "fieldset" || !elm.name){
+ continue;
+ }
+ var name = enc(elm.name);
+ var type = elm.type.toLowerCase();
+
+ if(type == "select-multiple"){
+ for(var j = 0; j < elm.options.length; j++){
+ if(elm.options[j].selected) {
+ values.push(name + "=" + enc(elm.options[j].value));
+ }
+ }
+ }else if(dojo.lang.inArray(type, ["radio", "checkbox"])){
+ if(elm.checked){
+ values.push(name + "=" + enc(elm.value));
+ }
+ }else if(!dojo.lang.inArray(type, ["file", "submit", "reset", "button"])) {
+ values.push(name + "=" + enc(elm.value));
+ }
+ }
+
+ // now collect input type="image", which doesn't show up in the elements array
+ var inputs = formNode.getElementsByTagName("input");
+ for(var i = 0; i < inputs.length; i++) {
+ var input = inputs[i];
+ if(input.type.toLowerCase() == "image" && input.form == formNode) {
+ var name = enc(input.name);
+ values.push(name + "=" + enc(input.value));
+ values.push(name + ".x=0");
+ values.push(name + ".y=0");
+ }
+ }
+ return values.join("&") + "&";
+}
+
+dojo.io.setIFrameSrc = function(iframe, src, replace){
+ try{
+ var r = dojo.render.html;
+ // dojo.debug(iframe);
+ if(!replace){
+ if(r.safari){
+ iframe.location = src;
+ }else{
+ frames[iframe.name].location = src;
+ }
+ }else{
+ // Fun with DOM 0 incompatibilities!
+ var idoc;
+ if(r.ie){
+ idoc = iframe.contentWindow.document;
+ }else if(r.moz){
+ idoc = iframe.contentWindow;
+ }else if(r.safari){
+ idoc = iframe.document;
+ }
+ idoc.location.replace(src);
+ }
+ }catch(e){
+ dojo.debug(e);
+ dojo.debug("setIFrameSrc: "+e);
+ }
+}
+
+dojo.io.XMLHTTPTransport = new function(){
+ var _this = this;
+
+ this.initialHref = window.location.href;
+ this.initialHash = window.location.hash;
+
+ this.moveForward = false;
+
+ var _cache = {}; // FIXME: make this public? do we even need to?
+ this.useCache = false; // if this is true, we'll cache unless kwArgs.useCache = false
+ this.preventCache = false; // if this is true, we'll always force GET requests to cache
+ this.historyStack = [];
+ this.forwardStack = [];
+ this.historyIframe = null;
+ this.bookmarkAnchor = null;
+ this.locationTimer = null;
+
+ /* NOTES:
+ * Safari 1.2:
+ * back button "works" fine, however it's not possible to actually
+ * DETECT that you've moved backwards by inspecting window.location.
+ * Unless there is some other means of locating.
+ * FIXME: perhaps we can poll on history.length?
+ * IE 5.5 SP2:
+ * back button behavior is macro. It does not move back to the
+ * previous hash value, but to the last full page load. This suggests
+ * that the iframe is the correct way to capture the back button in
+ * these cases.
+ * IE 6.0:
+ * same behavior as IE 5.5 SP2
+ * Firefox 1.0:
+ * the back button will return us to the previous hash on the same
+ * page, thereby not requiring an iframe hack, although we do then
+ * need to run a timer to detect inter-page movement.
+ */
+
+ // FIXME: Should this even be a function? or do we just hard code it in the next 2 functions?
+ function getCacheKey(url, query, method) {
+ return url + "|" + query + "|" + method.toLowerCase();
+ }
+
+ function addToCache(url, query, method, http) {
+ _cache[getCacheKey(url, query, method)] = http;
+ }
+
+ function getFromCache(url, query, method) {
+ return _cache[getCacheKey(url, query, method)];
+ }
+
+ this.clearCache = function() {
+ _cache = {};
+ }
+
+ // moved successful load stuff here
+ function doLoad(kwArgs, http, url, query, useCache) {
+ if((http.status==200)||(location.protocol=="file:" && http.status==0)) {
+ var ret;
+ if(kwArgs.method.toLowerCase() == "head"){
+ var headers = http.getAllResponseHeaders();
+ ret = {};
+ ret.toString = function(){ return headers; }
+ var values = headers.split(/[\r\n]+/g);
+ for(var i = 0; i < values.length; i++) {
+ var pair = values[i].match(/^([^:]+)\s*:\s*(.+)$/i);
+ if(pair) {
+ ret[pair[1]] = pair[2];
+ }
+ }
+ }else if(kwArgs.mimetype == "text/javascript"){
+ try{
+ ret = dj_eval(http.responseText);
+ }catch(e){
+ dojo.debug(e);
+ dojo.debug(http.responseText);
+ ret = null;
+ }
+ }else if(kwArgs.mimetype == "text/json"){
+ try{
+ ret = dj_eval("("+http.responseText+")");
+ }catch(e){
+ dojo.debug(e);
+ dojo.debug(http.responseText);
+ ret = false;
+ }
+ }else if((kwArgs.mimetype == "application/xml")||
+ (kwArgs.mimetype == "text/xml")){
+ ret = http.responseXML;
+ if(!ret || typeof ret == "string") {
+ ret = dojo.dom.createDocumentFromText(http.responseText);
+ }
+ }else{
+ ret = http.responseText;
+ }
+
+ if(useCache){ // only cache successful responses
+ addToCache(url, query, kwArgs.method, http);
+ }
+ kwArgs[(typeof kwArgs.load == "function") ? "load" : "handle"]("load", ret, http);
+ }else{
+ var errObj = new dojo.io.Error("XMLHttpTransport Error: "+http.status+" "+http.statusText);
+ kwArgs[(typeof kwArgs.error == "function") ? "error" : "handle"]("error", errObj, http);
+ }
+ }
+
+ // set headers (note: Content-Type will get overriden if kwArgs.contentType is set)
+ function setHeaders(http, kwArgs){
+ if(kwArgs["headers"]) {
+ for(var header in kwArgs["headers"]) {
+ if(header.toLowerCase() == "content-type" && !kwArgs["contentType"]) {
+ kwArgs["contentType"] = kwArgs["headers"][header];
+ } else {
+ http.setRequestHeader(header, kwArgs["headers"][header]);
+ }
+ }
+ }
+ }
+
+ this.addToHistory = function(args){
+ var callback = args["back"]||args["backButton"]||args["handle"];
+ var hash = null;
+ if(!this.historyIframe){
+ this.historyIframe = window.frames["djhistory"];
+ }
+ if(!this.bookmarkAnchor){
+ this.bookmarkAnchor = document.createElement("a");
+ (document.body||document.getElementsByTagName("body")[0]).appendChild(this.bookmarkAnchor);
+ this.bookmarkAnchor.style.display = "none";
+ }
+ if((!args["changeUrl"])||(dojo.render.html.ie)){
+ var url = dojo.hostenv.getBaseScriptUri()+"iframe_history.html?"+(new Date()).getTime();
+ this.moveForward = true;
+ dojo.io.setIFrameSrc(this.historyIframe, url, false);
+ }
+ if(args["changeUrl"]){
+ hash = "#"+ ((args["changeUrl"]!==true) ? args["changeUrl"] : (new Date()).getTime());
+ setTimeout("window.location.href = '"+hash+"';", 1);
+ this.bookmarkAnchor.href = hash;
+ if(dojo.render.html.ie){
+ // IE requires manual setting of the hash since we are catching
+ // events from the iframe
+ var oldCB = callback;
+ var lh = null;
+ var hsl = this.historyStack.length-1;
+ if(hsl>=0){
+ while(!this.historyStack[hsl]["urlHash"]){
+ hsl--;
+ }
+ lh = this.historyStack[hsl]["urlHash"];
+ }
+ if(lh){
+ callback = function(){
+ if(window.location.hash != ""){
+ setTimeout("window.location.href = '"+lh+"';", 1);
+ }
+ oldCB();
+ }
+ }
+ // when we issue a new bind(), we clobber the forward
+ // FIXME: is this always a good idea?
+ this.forwardStack = [];
+ var oldFW = args["forward"]||args["forwardButton"];;
+ var tfw = function(){
+ if(window.location.hash != ""){
+ window.location.href = hash;
+ }
+ if(oldFW){ // we might not actually have one
+ oldFW();
+ }
+ }
+ if(args["forward"]){
+ args.forward = tfw;
+ }else if(args["forwardButton"]){
+ args.forwardButton = tfw;
+ }
+ }else if(dojo.render.html.moz){
+ // start the timer
+ if(!this.locationTimer){
+ this.locationTimer = setInterval("dojo.io.XMLHTTPTransport.checkLocation();", 200);
+ }
+ }
+ }
+
+ this.historyStack.push({"url": url, "callback": callback, "kwArgs": args, "urlHash": hash});
+ }
+
+ this.checkLocation = function(){
+ var hsl = this.historyStack.length;
+
+ if((window.location.hash == this.initialHash)||(window.location.href == this.initialHref)&&(hsl == 1)){
+ // FIXME: could this ever be a forward button?
+ // we can't clear it because we still need to check for forwards. Ugg.
+ // clearInterval(this.locationTimer);
+ this.handleBackButton();
+ return;
+ }
+ // first check to see if we could have gone forward. We always halt on
+ // a no-hash item.
+ if(this.forwardStack.length > 0){
+ if(this.forwardStack[this.forwardStack.length-1].urlHash == window.location.hash){
+ this.handleForwardButton();
+ return;
+ }
+ }
+ // ok, that didn't work, try someplace back in the history stack
+ if((hsl >= 2)&&(this.historyStack[hsl-2])){
+ if(this.historyStack[hsl-2].urlHash==window.location.hash){
+ this.handleBackButton();
+ return;
+ }
+ }
+ }
+
+ this.iframeLoaded = function(evt, ifrLoc){
+ var isp = ifrLoc.href.split("?");
+ if(isp.length < 2){
+ // alert("iframeLoaded");
+ // we hit the end of the history, so we should go back
+ if(this.historyStack.length == 1){
+ this.handleBackButton();
+ }
+ return;
+ }
+ var query = isp[1];
+ if(this.moveForward){
+ // we were expecting it, so it's not either a forward or backward
+ // movement
+ this.moveForward = false;
+ return;
+ }
+
+ var last = this.historyStack.pop();
+ // we don't have anything in history, so it could be a forward button
+ if(!last){
+ if(this.forwardStack.length > 0){
+ var next = this.forwardStack[this.forwardStack.length-1];
+ if(query == next.url.split("?")[1]){
+ this.handleForwardButton();
+ }
+ }
+ // regardless, we didnt' have any history, so it can't be a back button
+ return;
+ }
+ // put it back on the stack so we can do something useful with it when
+ // we call handleBackButton()
+ this.historyStack.push(last);
+ if(this.historyStack.length >= 2){
+ if(isp[1] == this.historyStack[this.historyStack.length-2].url.split("?")[1]){
+ // looks like it IS a back button press, so handle it
+ this.handleBackButton();
+ }
+ }else{
+ this.handleBackButton();
+ }
+ }
+
+ this.handleBackButton = function(){
+ var last = this.historyStack.pop();
+ if(!last){ return; }
+ if(last["callback"]){
+ last.callback();
+ }else if(last.kwArgs["backButton"]){
+ last.kwArgs["backButton"]();
+ }else if(last.kwArgs["back"]){
+ last.kwArgs["back"]();
+ }else if(last.kwArgs["handle"]){
+ last.kwArgs.handle("back");
+ }
+ this.forwardStack.push(last);
+ }
+
+ this.handleForwardButton = function(){
+ // FIXME: should we build in support for re-issuing the bind() call here?
+ // alert("alert we found a forward button call");
+ var last = this.forwardStack.pop();
+ if(!last){ return; }
+ if(last.kwArgs["forward"]){
+ last.kwArgs.forward();
+ }else if(last.kwArgs["forwardButton"]){
+ last.kwArgs.forwardButton();
+ }else if(last.kwArgs["handle"]){
+ last.kwArgs.handle("forward");
+ }
+ this.historyStack.push(last);
+ }
+
+ this.inFlight = [];
+ this.inFlightTimer = null;
+
+ this.startWatchingInFlight = function(){
+ if(!this.inFlightTimer){
+ this.inFlightTimer = setInterval("dojo.io.XMLHTTPTransport.watchInFlight();", 10);
+ }
+ }
+
+ this.watchInFlight = function(){
+ for(var x=this.inFlight.length-1; x>=0; x--){
+ var tif = this.inFlight[x];
+ if(!tif){ this.inFlight.splice(x, 1); continue; }
+ if(4==tif.http.readyState){
+ // remove it so we can clean refs
+ this.inFlight.splice(x, 1);
+ doLoad(tif.req, tif.http, tif.url, tif.query, tif.useCache);
+ if(this.inFlight.length == 0){
+ clearInterval(this.inFlightTimer);
+ this.inFlightTimer = null;
+ }
+ } // FIXME: need to implement a timeout param here!
+ }
+ }
+
+ var hasXmlHttp = dojo.hostenv.getXmlhttpObject() ? true : false;
+ this.canHandle = function(kwArgs){
+ // canHandle just tells dojo.io.bind() if this is a good transport to
+ // use for the particular type of request.
+
+ // FIXME: we need to determine when form values need to be
+ // multi-part mime encoded and avoid using this transport for those
+ // requests.
+ return hasXmlHttp
+ && dojo.lang.inArray((kwArgs["mimetype"]||"".toLowerCase()), ["text/plain", "text/html", "application/xml", "text/xml", "text/javascript", "text/json"])
+ && dojo.lang.inArray(kwArgs["method"].toLowerCase(), ["post", "get", "head"])
+ && !( kwArgs["formNode"] && dojo.io.formHasFile(kwArgs["formNode"]) );
+ }
+
+ this.multipartBoundary = "45309FFF-BD65-4d50-99C9-36986896A96F"; // unique guid as a boundary value for multipart posts
+
+ this.bind = function(kwArgs){
+ if(!kwArgs["url"]){
+ // are we performing a history action?
+ if( !kwArgs["formNode"]
+ && (kwArgs["backButton"] || kwArgs["back"] || kwArgs["changeUrl"] || kwArgs["watchForURL"])
+ && (!djConfig.preventBackButtonFix)) {
+ this.addToHistory(kwArgs);
+ return true;
+ }
+ }
+
+ // build this first for cache purposes
+ var url = kwArgs.url;
+ var query = "";
+ if(kwArgs["formNode"]){
+ var ta = kwArgs.formNode.getAttribute("action");
+ if((ta)&&(!kwArgs["url"])){ url = ta; }
+ var tp = kwArgs.formNode.getAttribute("method");
+ if((tp)&&(!kwArgs["method"])){ kwArgs.method = tp; }
+ query += dojo.io.encodeForm(kwArgs.formNode, kwArgs.encoding);
+ }
+
+ if(url.indexOf("#") > -1) {
+ dojo.debug("Warning: dojo.io.bind: stripping hash values from url:", url);
+ url = url.split("#")[0];
+ }
+
+ if(kwArgs["file"]){
+ // force post for file transfer
+ kwArgs.method = "post";
+ }
+
+ if(!kwArgs["method"]){
+ kwArgs.method = "get";
+ }
+
+ // guess the multipart value
+ if(kwArgs.method.toLowerCase() == "get"){
+ // GET cannot use multipart
+ kwArgs.multipart = false;
+ }else{
+ if(kwArgs["file"]){
+ // enforce multipart when sending files
+ kwArgs.multipart = true;
+ }else if(!kwArgs["multipart"]){
+ // default
+ kwArgs.multipart = false;
+ }
+ }
+
+ if(kwArgs["backButton"] || kwArgs["back"] || kwArgs["changeUrl"]){
+ this.addToHistory(kwArgs);
+ }
+
+ var content = kwArgs["content"] || {};
+
+ if(kwArgs.sendTransport) {
+ content["dojo.transport"] = "xmlhttp";
+ }
+
+ do { // break-block
+ if(kwArgs.postContent){
+ query = kwArgs.postContent;
+ break;
+ }
+
+ if(content) {
+ query += dojo.io.argsFromMap(content, kwArgs.encoding);
+ }
+
+ if(kwArgs.method.toLowerCase() == "get" || !kwArgs.multipart){
+ break;
+ }
+
+ var t = [];
+ if(query.length){
+ var q = query.split("&");
+ for(var i = 0; i < q.length; ++i){
+ if(q[i].length){
+ var p = q[i].split("=");
+ t.push( "--" + this.multipartBoundary,
+ "Content-Disposition: form-data; name=\"" + p[0] + "\"",
+ "",
+ p[1]);
+ }
+ }
+ }
+
+ if(kwArgs.file){
+ if(dojo.lang.isArray(kwArgs.file)){
+ for(var i = 0; i < kwArgs.file.length; ++i){
+ var o = kwArgs.file[i];
+ t.push( "--" + this.multipartBoundary,
+ "Content-Disposition: form-data; name=\"" + o.name + "\"; filename=\"" + ("fileName" in o ? o.fileName : o.name) + "\"",
+ "Content-Type: " + ("contentType" in o ? o.contentType : "application/octet-stream"),
+ "",
+ o.content);
+ }
+ }else{
+ var o = kwArgs.file;
+ t.push( "--" + this.multipartBoundary,
+ "Content-Disposition: form-data; name=\"" + o.name + "\"; filename=\"" + ("fileName" in o ? o.fileName : o.name) + "\"",
+ "Content-Type: " + ("contentType" in o ? o.contentType : "application/octet-stream"),
+ "",
+ o.content);
+ }
+ }
+
+ if(t.length){
+ t.push("--"+this.multipartBoundary+"--", "");
+ query = t.join("\r\n");
+ }
+ }while(false);
+
+ // kwArgs.Connection = "close";
+
+ var async = kwArgs["sync"] ? false : true;
+
+ var preventCache = kwArgs["preventCache"] ||
+ (this.preventCache == true && kwArgs["preventCache"] != false);
+ var useCache = kwArgs["useCache"] == true ||
+ (this.useCache == true && kwArgs["useCache"] != false );
+
+ // preventCache is browser-level (add query string junk), useCache
+ // is for the local cache. If we say preventCache, then don't attempt
+ // to look in the cache, but if useCache is true, we still want to cache
+ // the response
+ if(!preventCache && useCache){
+ var cachedHttp = getFromCache(url, query, kwArgs.method);
+ if(cachedHttp){
+ doLoad(kwArgs, cachedHttp, url, query, false);
+ return;
+ }
+ }
+
+ // much of this is from getText, but reproduced here because we need
+ // more flexibility
+ var http = dojo.hostenv.getXmlhttpObject();
+ var received = false;
+
+ // build a handler function that calls back to the handler obj
+ if(async){
+ // FIXME: setting up this callback handler leaks on IE!!!
+ this.inFlight.push({
+ "req": kwArgs,
+ "http": http,
+ "url": url,
+ "query": query,
+ "useCache": useCache
+ });
+ this.startWatchingInFlight();
+ }
+
+ if(kwArgs.method.toLowerCase() == "post"){
+ // FIXME: need to hack in more flexible Content-Type setting here!
+ http.open("POST", url, async);
+ setHeaders(http, kwArgs);
+ http.setRequestHeader("Content-Type", kwArgs.multipart ? ("multipart/form-data; boundary=" + this.multipartBoundary) :
+ (kwArgs.contentType || "application/x-www-form-urlencoded"));
+ http.send(query);
+ }else{
+ var tmpUrl = url;
+ if(query != "") {
+ tmpUrl += (tmpUrl.indexOf("?") > -1 ? "&" : "?") + query;
+ }
+ if(preventCache) {
+ tmpUrl += (dojo.string.endsWithAny(tmpUrl, "?", "&")
+ ? "" : (tmpUrl.indexOf("?") > -1 ? "&" : "?")) + "dojo.preventCache=" + new Date().valueOf();
+ }
+ http.open(kwArgs.method.toUpperCase(), tmpUrl, async);
+ setHeaders(http, kwArgs);
+ http.send(null);
+ }
+
+ if( !async ) {
+ doLoad(kwArgs, http, url, query, useCache);
+ }
+
+ kwArgs.abort = function(){
+ return http.abort();
+ }
+
+ return;
+ }
+ dojo.io.transports.addTransport("XMLHTTPTransport");
+}
Added: myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io/IframeIO.js
URL: http://svn.apache.org/viewcvs/myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io/IframeIO.js?rev=372668&view=auto
==============================================================================
--- myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io/IframeIO.js (added)
+++ myfaces/tomahawk/trunk/sandbox/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/src/io/IframeIO.js Thu Jan 26 15:56:50 2006
@@ -0,0 +1,219 @@
+/*
+ Copyright (c) 2004-2005, 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.io.IframeIO");
+dojo.require("dojo.io.BrowserIO");
+dojo.require("dojo.uri.*");
+
+dojo.io.createIFrame = function(fname, onloadstr){
+ if(window[fname]){ return window[fname]; }
+ if(window.frames[fname]){ return window.frames[fname]; }
+ var r = dojo.render.html;
+ var cframe = null;
+ var turi = dojo.uri.dojoUri("iframe_history.html?noInit=true");
+ var ifrstr = ((r.ie)&&(dojo.render.os.win)) ? "<iframe name='"+fname+"' src='"+turi+"' onload='"+onloadstr+"'>" : "iframe";
+ cframe = document.createElement(ifrstr);
+ with(cframe){
+ name = fname;
+ setAttribute("name", fname);
+ id = fname;
+ }
+ (document.body||document.getElementsByTagName("body")[0]).appendChild(cframe);
+ window[fname] = cframe;
+ with(cframe.style){
+ position = "absolute";
+ left = top = "0px";
+ height = width = "1px";
+ visibility = "hidden";
+ /*
+ if(djConfig.isDebug){
+ position = "relative";
+ height = "300px";
+ width = "600px";
+ visibility = "visible";
+ }
+ */
+ }
+
+ if(!r.ie){
+ dojo.io.setIFrameSrc(cframe, turi, true);
+ cframe.onload = new Function(onloadstr);
+ }
+ return cframe;
+}
+
+// thanks burstlib!
+dojo.io.iframeContentWindow = function(iframe_el) {
+ var win = iframe_el.contentWindow || // IE
+ dojo.io.iframeContentDocument(iframe_el).defaultView || // Moz, opera
+ // Moz. TODO: is this available when defaultView isn't?
+ dojo.io.iframeContentDocument(iframe_el).__parent__ ||
+ (iframe_el.name && document.frames[iframe_el.name]) || null;
+ return win;
+}
+
+dojo.io.iframeContentDocument = function(iframe_el){
+ var doc = iframe_el.contentDocument || // W3
+ (
+ (iframe_el.contentWindow)&&(iframe_el.contentWindow.document)
+ ) || // IE
+ (
+ (iframe_el.name)&&(document.frames[iframe_el.name])&&
+ (document.frames[iframe_el.name].document)
+ ) || null;
+ return doc;
+}
+
+dojo.io.IframeTransport = new function(){
+ var _this = this;
+ this.currentRequest = null;
+ this.requestQueue = [];
+ this.iframeName = "dojoIoIframe";
+
+ this.fireNextRequest = function(){
+ if((this.currentRequest)||(this.requestQueue.length == 0)){ return; }
+ // dojo.debug("fireNextRequest");
+ var cr = this.currentRequest = this.requestQueue.shift();
+ var fn = cr["formNode"];
+ var content = cr["content"] || {};
+ if(cr.sendTransport) {
+ content["dojo.transport"] = "iframe";
+ }
+ if(fn){
+ if(content){
+ // if we have things in content, we need to add them to the form
+ // before submission
+ for(var x in content){
+ if(!fn[x]){
+ var tn;
+ if(dojo.render.html.ie){
+ tn = document.createElement("<input type='hidden' name='"+x+"' value='"+content[x]+"'>");
+ fn.appendChild(tn);
+ }else{
+ tn = document.createElement("input");
+ fn.appendChild(tn);
+ tn.type = "hidden";
+ tn.name = x;
+ tn.value = content[x];
+ }
+ }else{
+ fn[x].value = content[x];
+ }
+ }
+ }
+ if(cr["url"]){
+ fn.setAttribute("action", cr.url);
+ }
+ if(!fn.getAttribute("method")){
+ fn.setAttribute("method", (cr["method"]) ? cr["method"] : "post");
+ }
+ fn.setAttribute("target", this.iframeName);
+ fn.target = this.iframeName;
+ fn.submit();
+ }else{
+ // otherwise we post a GET string by changing URL location for the
+ // iframe
+ var query = dojo.io.argsFromMap(this.currentRequest.content);
+ var tmpUrl = (cr.url.indexOf("?") > -1 ? "&" : "?") + query;
+ dojo.io.setIFrameSrc(this.iframe, tmpUrl, true);
+ }
+ }
+
+ this.canHandle = function(kwArgs){
+ return (
+ (
+ // FIXME: can we really handle text/plain and
+ // text/javascript requests?
+ dojo.lang.inArray(kwArgs["mimetype"],
+ [ "text/plain", "text/html",
+ "application/xml", "text/xml",
+ "text/javascript", "text/json"])
+ )&&(
+ // make sur we really only get used in file upload cases
+ (kwArgs["formNode"])&&(dojo.io.checkChildrenForFile(kwArgs["formNode"]))
+ )&&(
+ dojo.lang.inArray(kwArgs["method"].toLowerCase(), ["post", "get"])
+ )&&(
+ // never handle a sync request
+ ! ((kwArgs["sync"])&&(kwArgs["sync"] == true))
+ )
+ );
+ }
+
+ this.bind = function(kwArgs){
+ this.requestQueue.push(kwArgs);
+ this.fireNextRequest();
+ return;
+ }
+
+ this.setUpIframe = function(){
+
+ // NOTE: IE 5.0 and earlier Mozilla's don't support an onload event for
+ // iframes. OTOH, we don't care.
+ this.iframe = dojo.io.createIFrame(this.iframeName, "dojo.io.IframeTransport.iframeOnload();");
+ }
+
+ this.iframeOnload = function(){
+ if(!_this.currentRequest){
+ _this.fireNextRequest();
+ return;
+ }
+ var ifr = _this.iframe;
+ var ifw = dojo.io.iframeContentWindow(ifr);
+ // handle successful returns
+ // FIXME: how do we determine success for iframes? Is there an equiv of
+ // the "status" property?
+ var value;
+ var success = false;
+
+ try{
+ var cmt = _this.currentRequest.mimetype;
+ if((cmt == "text/javascript")||(cmt == "text/json")){
+ // FIXME: not sure what to do here? try to pull some evalulable
+ // text from a textarea or cdata section?
+ // how should we set up the contract for that?
+ var cd = dojo.io.iframeContentDocument(_this.iframe);
+ var js = cd.getElementsByTagName("textarea")[0].value;
+ if(cmt == "text/json") { js = "(" + js + ")"; }
+ value = dj_eval(js);
+ }else if((cmt == "application/xml")||(cmt == "text/xml")){
+ value = dojo.io.iframeContentDocument(_this.iframe);
+ }else{ // text/plain
+ value = ifw.innerHTML;
+ }
+ success = true;
+ }catch(e){
+ // looks like we didn't get what we wanted!
+ var errObj = new dojo.io.Error("IframeTransport Error");
+ if(dojo.lang.isFunction(_this.currentRequest["error"])){
+ _this.currentRequest.error("error", errObj, _this.currentRequest);
+ }
+ }
+
+ // don't want to mix load function errors with processing errors, thus
+ // a separate try..catch
+ try {
+ if(success && dojo.lang.isFunction(_this.currentRequest["load"])){
+ _this.currentRequest.load("load", value, _this.currentRequest);
+ }
+ } catch(e) {
+ throw e;
+ } finally {
+ _this.currentRequest = null;
+ _this.fireNextRequest();
+ }
+ }
+
+ dojo.io.transports.addTransport("IframeTransport");
+}
+
+dojo.addOnLoad(function(){
+ dojo.io.IframeTransport.setUpIframe();
+});