4 ) { coords.pop(); }
+ var ret = {
+ left: coords[0],
+ top: coords[1],
+ width: coords[2],
+ height: coords[3]
+ };
+ }else if(!coords.nodeType && !(coords instanceof String || typeof coords == "string") &&
+ ('width' in coords || 'height' in coords || 'left' in coords ||
+ 'x' in coords || 'top' in coords || 'y' in coords)){
+ // coords is a coordinate object or at least part of one
+ var ret = {
+ left: coords.left||coords.x||0,
+ top: coords.top||coords.y||0,
+ width: coords.width||0,
+ height: coords.height||0
+ };
+ }else{
+ // coords is an dom object (or dom object id); return it's coordinates
+ var node = dojo.byId(coords);
+ var pos = dojo.html.abs(node, includeScroll, boxtype);
+ var marginbox = dojo.html.getMarginBox(node);
+ var ret = {
+ left: pos.left,
+ top: pos.top,
+ width: marginbox.width,
+ height: marginbox.height
+ };
+ }
+ ret.x = ret.left;
+ ret.y = ret.top;
+ return ret; // object
+}
+
+dojo.html.setMarginBoxWidth = dojo.html.setOuterWidth = function(node, width){
+ return dojo.html._callDeprecated("setMarginBoxWidth", "setMarginBox", arguments, "width");
+}
+dojo.html.setMarginBoxHeight = dojo.html.setOuterHeight = function(){
+ return dojo.html._callDeprecated("setMarginBoxHeight", "setMarginBox", arguments, "height");
+}
+dojo.html.getMarginBoxWidth = dojo.html.getOuterWidth = function(){
+ return dojo.html._callDeprecated("getMarginBoxWidth", "getMarginBox", arguments, null, "width");
+}
+dojo.html.getMarginBoxHeight = dojo.html.getOuterHeight = function(){
+ return dojo.html._callDeprecated("getMarginBoxHeight", "getMarginBox", arguments, null, "height");
+}
+dojo.html.getTotalOffset = function(node, type, includeScroll){
+ return dojo.html._callDeprecated("getTotalOffset", "getAbsolutePosition", arguments, null, type);
+}
+dojo.html.getAbsoluteX = function(node, includeScroll){
+ return dojo.html._callDeprecated("getAbsoluteX", "getAbsolutePosition", arguments, null, "x");
+}
+dojo.html.getAbsoluteY = function(node, includeScroll){
+ return dojo.html._callDeprecated("getAbsoluteY", "getAbsolutePosition", arguments, null, "y");
+}
+dojo.html.totalOffsetLeft = function(node, includeScroll){
+ return dojo.html._callDeprecated("totalOffsetLeft", "getAbsolutePosition", arguments, null, "left");
+}
+dojo.html.totalOffsetTop = function(node, includeScroll){
+ return dojo.html._callDeprecated("totalOffsetTop", "getAbsolutePosition", arguments, null, "top");
+}
+dojo.html.getMarginWidth = function(node){
+ return dojo.html._callDeprecated("getMarginWidth", "getMargin", arguments, null, "width");
+}
+dojo.html.getMarginHeight = function(node){
+ return dojo.html._callDeprecated("getMarginHeight", "getMargin", arguments, null, "height");
+}
+dojo.html.getBorderWidth = function(node){
+ return dojo.html._callDeprecated("getBorderWidth", "getBorder", arguments, null, "width");
+}
+dojo.html.getBorderHeight = function(node){
+ return dojo.html._callDeprecated("getBorderHeight", "getBorder", arguments, null, "height");
+}
+dojo.html.getPaddingWidth = function(node){
+ return dojo.html._callDeprecated("getPaddingWidth", "getPadding", arguments, null, "width");
+}
+dojo.html.getPaddingHeight = function(node){
+ return dojo.html._callDeprecated("getPaddingHeight", "getPadding", arguments, null, "height");
+}
+dojo.html.getPadBorderWidth = function(node){
+ return dojo.html._callDeprecated("getPadBorderWidth", "getPadBorder", arguments, null, "width");
+}
+dojo.html.getPadBorderHeight = function(node){
+ return dojo.html._callDeprecated("getPadBorderHeight", "getPadBorder", arguments, null, "height");
+}
+dojo.html.getBorderBoxWidth = dojo.html.getInnerWidth = function(){
+ return dojo.html._callDeprecated("getBorderBoxWidth", "getBorderBox", arguments, null, "width");
+}
+dojo.html.getBorderBoxHeight = dojo.html.getInnerHeight = function(){
+ return dojo.html._callDeprecated("getBorderBoxHeight", "getBorderBox", arguments, null, "height");
+}
+dojo.html.getContentBoxWidth = dojo.html.getContentWidth = function(){
+ return dojo.html._callDeprecated("getContentBoxWidth", "getContentBox", arguments, null, "width");
+}
+dojo.html.getContentBoxHeight = dojo.html.getContentHeight = function(){
+ return dojo.html._callDeprecated("getContentBoxHeight", "getContentBox", arguments, null, "height");
+}
+dojo.html.setContentBoxWidth = dojo.html.setContentWidth = function(node, width){
+ return dojo.html._callDeprecated("setContentBoxWidth", "setContentBox", arguments, "width");
+}
+dojo.html.setContentBoxHeight = dojo.html.setContentHeight = function(node, height){
+ return dojo.html._callDeprecated("setContentBoxHeight", "setContentBox", arguments, "height");
+}
+
+dojo.provide("dojo.lfx.html");
+
+
+dojo.lfx.html._byId = function(nodes){
+ if(!nodes){ return []; }
+ if(dojo.lang.isArrayLike(nodes)){
+ if(!nodes.alreadyChecked){
+ var n = [];
+ dojo.lang.forEach(nodes, function(node){
+ n.push(dojo.byId(node));
+ });
+ n.alreadyChecked = true;
+ return n;
+ }else{
+ return nodes;
+ }
+ }else{
+ var n = [];
+ n.push(dojo.byId(nodes));
+ n.alreadyChecked = true;
+ return n;
+ }
+}
+
+dojo.lfx.html.propertyAnimation = function( /*DOMNode[]*/ nodes,
+ /*Object[]*/ propertyMap,
+ /*int*/ duration,
+ /*function*/ easing,
+ /*Object*/ handlers){
+ // summary: Returns an animation that will transition the properties of "nodes"
+ // depending how they are defined in "propertyMap".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // propertyMap: { property: String, start: Decimal?, end: Decimal?, units: String? }
+ // An array of objects defining properties to change.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // handlers: { handler: Function?, onstart: Function?, onstop: Function?, onanimate: Function? }
+ nodes = dojo.lfx.html._byId(nodes);
+
+ var targs = {
+ "propertyMap": propertyMap,
+ "nodes": nodes,
+ "duration": duration,
+ "easing": easing||dojo.lfx.easeDefault
+ };
+
+ var setEmUp = function(args){
+ if(args.nodes.length==1){
+ // FIXME: we're only supporting start-value filling when one node is
+ // passed
+
+ var pm = args.propertyMap;
+ if(!dojo.lang.isArray(args.propertyMap)){
+ // it's stupid to have to pack an array with a set of objects
+ // when you can just pass in an object list
+ var parr = [];
+ for(var pname in pm){
+ pm[pname].property = pname;
+ parr.push(pm[pname]);
+ }
+ pm = args.propertyMap = parr;
+ }
+ dojo.lang.forEach(pm, function(prop){
+ if(dj_undef("start", prop)){
+ if(prop.property != "opacity"){
+ prop.start = parseInt(dojo.html.getComputedStyle(args.nodes[0], prop.property));
+ }else{
+ prop.start = dojo.html.getOpacity(args.nodes[0]);
+ }
+ }
+ });
+ }
+ }
+
+ var coordsAsInts = function(coords){
+ var cints = [];
+ dojo.lang.forEach(coords, function(c){
+ cints.push(Math.round(c));
+ });
+ return cints;
+ }
+
+ var setStyle = function(n, style){
+ n = dojo.byId(n);
+ if(!n || !n.style){ return; }
+ for(var s in style){
+ if(s == "opacity"){
+ dojo.html.setOpacity(n, style[s]);
+ }else{
+ n.style[s] = style[s];
+ }
+ }
+ }
+
+ var propLine = function(properties){
+ this._properties = properties;
+ this.diffs = new Array(properties.length);
+ dojo.lang.forEach(properties, function(prop, i){
+ // calculate the end - start to optimize a bit
+ if(dojo.lang.isFunction(prop.start)){
+ prop.start = prop.start(prop, i);
+ }
+ if(dojo.lang.isFunction(prop.end)){
+ prop.end = prop.end(prop, i);
+ }
+ if(dojo.lang.isArray(prop.start)){
+ // don't loop through the arrays
+ this.diffs[i] = null;
+ }else if(prop.start instanceof dojo.gfx.color.Color){
+ // save these so we don't have to call toRgb() every getValue() call
+ prop.startRgb = prop.start.toRgb();
+ prop.endRgb = prop.end.toRgb();
+ }else{
+ this.diffs[i] = prop.end - prop.start;
+ }
+ }, this);
+
+ this.getValue = function(n){
+ var ret = {};
+ dojo.lang.forEach(this._properties, function(prop, i){
+ var value = null;
+ if(dojo.lang.isArray(prop.start)){
+ // FIXME: what to do here?
+ }else if(prop.start instanceof dojo.gfx.color.Color){
+ value = (prop.units||"rgb") + "(";
+ for(var j = 0 ; j < prop.startRgb.length ; j++){
+ value += Math.round(((prop.endRgb[j] - prop.startRgb[j]) * n) + prop.startRgb[j]) + (j < prop.startRgb.length - 1 ? "," : "");
+ }
+ value += ")";
+ }else{
+ value = ((this.diffs[i]) * n) + prop.start + (prop.property != "opacity" ? prop.units||"px" : "");
+ }
+ ret[dojo.html.toCamelCase(prop.property)] = value;
+ }, this);
+ return ret;
+ }
+ }
+
+ var anim = new dojo.lfx.Animation({
+ beforeBegin: function(){
+ setEmUp(targs);
+ anim.curve = new propLine(targs.propertyMap);
+ },
+ onAnimate: function(propValues){
+ dojo.lang.forEach(targs.nodes, function(node){
+ setStyle(node, propValues);
+ });
+ }
+ },
+ targs.duration,
+ null,
+ targs.easing
+ );
+ if(handlers){
+ for(var x in handlers){
+ if(dojo.lang.isFunction(handlers[x])){
+ anim.connect(x, anim, handlers[x]);
+ }
+ }
+ }
+
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html._makeFadeable = function(nodes){
+ var makeFade = function(node){
+ if(dojo.render.html.ie){
+ // only set the zoom if the "tickle" value would be the same as the
+ // default
+ if( (node.style.zoom.length == 0) &&
+ (dojo.html.getStyle(node, "zoom") == "normal") ){
+ // make sure the node "hasLayout"
+ // NOTE: this has been tested with larger and smaller user-set text
+ // sizes and works fine
+ node.style.zoom = "1";
+ // node.style.zoom = "normal";
+ }
+ // don't set the width to auto if it didn't already cascade that way.
+ // We don't want to f anyones designs
+ if( (node.style.width.length == 0) &&
+ (dojo.html.getStyle(node, "width") == "auto") ){
+ node.style.width = "auto";
+ }
+ }
+ }
+ if(dojo.lang.isArrayLike(nodes)){
+ dojo.lang.forEach(nodes, makeFade);
+ }else{
+ makeFade(nodes);
+ }
+}
+
+dojo.lfx.html.fade = function(/*DOMNode[]*/ nodes,
+ /*Object*/values,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary:Returns an animation that will fade the "nodes" from the start to end values passed.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // values: { start: Decimal?, end: Decimal? }
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var props = { property: "opacity" };
+ if(!dj_undef("start", values)){
+ props.start = values.start;
+ }else{
+ props.start = function(){ return dojo.html.getOpacity(nodes[0]); };
+ }
+
+ if(!dj_undef("end", values)){
+ props.end = values.end;
+ }else{
+ dojo.raise("dojo.lfx.html.fade needs an end value");
+ }
+
+ var anim = dojo.lfx.propertyAnimation(nodes, [ props ], duration, easing);
+ anim.connect("beforeBegin", function(){
+ dojo.lfx.html._makeFadeable(nodes);
+ });
+ if(callback){
+ anim.connect("onEnd", function(){ callback(nodes, anim); });
+ }
+
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html.fadeIn = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will fade "nodes" from its current opacity to fully opaque.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ return dojo.lfx.html.fade(nodes, { end: 1 }, duration, easing, callback); // dojo.lfx.Animation
+}
+
+dojo.lfx.html.fadeOut = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will fade "nodes" from its current opacity to fully transparent.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ return dojo.lfx.html.fade(nodes, { end: 0 }, duration, easing, callback); // dojo.lfx.Animation
+}
+
+dojo.lfx.html.fadeShow = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will fade "nodes" from transparent to opaque and shows
+ // "nodes" at the end if it is hidden.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes=dojo.lfx.html._byId(nodes);
+ dojo.lang.forEach(nodes, function(node){
+ dojo.html.setOpacity(node, 0.0);
+ });
+
+ var anim = dojo.lfx.html.fadeIn(nodes, duration, easing, callback);
+ anim.connect("beforeBegin", function(){
+ if(dojo.lang.isArrayLike(nodes)){
+ dojo.lang.forEach(nodes, dojo.html.show);
+ }else{
+ dojo.html.show(nodes);
+ }
+ });
+
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html.fadeHide = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will fade "nodes" from its current opacity to opaque and hides
+ // "nodes" at the end.
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ var anim = dojo.lfx.html.fadeOut(nodes, duration, easing, function(){
+ if(dojo.lang.isArrayLike(nodes)){
+ dojo.lang.forEach(nodes, dojo.html.hide);
+ }else{
+ dojo.html.hide(nodes);
+ }
+ if(callback){ callback(nodes, anim); }
+ });
+
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html.wipeIn = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will show and wipe in "nodes".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+
+ dojo.lang.forEach(nodes, function(node){
+ var oprop = { }; // old properties of node (before we mucked w/them)
+
+ // get node height, either it's natural height or it's height specified via style or class attributes
+ // (for FF, the node has to be (temporarily) rendered to measure height)
+ dojo.html.show(node);
+ var height = dojo.html.getBorderBox(node).height;
+ dojo.html.hide(node);
+
+ var anim = dojo.lfx.propertyAnimation(node,
+ { "height": {
+ start: 1, // 0 causes IE to display the whole panel
+ end: function(){ return height; }
+ }
+ },
+ duration,
+ easing);
+
+ anim.connect("beforeBegin", function(){
+ oprop.overflow = node.style.overflow;
+ oprop.height = node.style.height;
+ with(node.style){
+ overflow = "hidden";
+ height = "1px"; // 0 causes IE to display the whole panel
+ }
+ dojo.html.show(node);
+ });
+
+ anim.connect("onEnd", function(){
+ with(node.style){
+ overflow = oprop.overflow;
+ height = oprop.height;
+ }
+ if(callback){ callback(node, anim); }
+ });
+ anims.push(anim);
+ });
+
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.html.wipeOut = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will wipe out and hide "nodes".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+
+ dojo.lang.forEach(nodes, function(node){
+ var oprop = { }; // old properties of node (before we mucked w/them)
+ var anim = dojo.lfx.propertyAnimation(node,
+ { "height": {
+ start: function(){ return dojo.html.getContentBox(node).height; },
+ end: 1 // 0 causes IE to display the whole panel
+ }
+ },
+ duration,
+ easing,
+ {
+ "beforeBegin": function(){
+ oprop.overflow = node.style.overflow;
+ oprop.height = node.style.height;
+ with(node.style){
+ overflow = "hidden";
+ }
+ dojo.html.show(node);
+ },
+
+ "onEnd": function(){
+ dojo.html.hide(node);
+ with(node.style){
+ overflow = oprop.overflow;
+ height = oprop.height;
+ }
+ if(callback){ callback(node, anim); }
+ }
+ }
+ );
+ anims.push(anim);
+ });
+
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.html.slideTo = function(/*DOMNode*/ nodes,
+ /*Object*/ coords,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will slide "nodes" from its current position to
+ // the position defined in "coords".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // coords: { top: Decimal?, left: Decimal? }
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+ var compute = dojo.html.getComputedStyle;
+
+ if(dojo.lang.isArray(coords)){
+ /* coords: Array
+ pId: a */
+ dojo.deprecated('dojo.lfx.html.slideTo(node, array)', 'use dojo.lfx.html.slideTo(node, {top: value, left: value});', '0.5');
+ coords = { top: coords[0], left: coords[1] };
+ }
+ dojo.lang.forEach(nodes, function(node){
+ var top = null;
+ var left = null;
+
+ var init = (function(){
+ var innerNode = node;
+ return function(){
+ var pos = compute(innerNode, 'position');
+ top = (pos == 'absolute' ? node.offsetTop : parseInt(compute(node, 'top')) || 0);
+ left = (pos == 'absolute' ? node.offsetLeft : parseInt(compute(node, 'left')) || 0);
+
+ if (!dojo.lang.inArray(['absolute', 'relative'], pos)) {
+ var ret = dojo.html.abs(innerNode, true);
+ dojo.html.setStyleAttributes(innerNode, "position:absolute;top:"+ret.y+"px;left:"+ret.x+"px;");
+ top = ret.y;
+ left = ret.x;
+ }
+ }
+ })();
+ init();
+
+ var anim = dojo.lfx.propertyAnimation(node,
+ { "top": { start: top, end: (coords.top||0) },
+ "left": { start: left, end: (coords.left||0) }
+ },
+ duration,
+ easing,
+ { "beforeBegin": init }
+ );
+
+ if(callback){
+ anim.connect("onEnd", function(){ callback(nodes, anim); });
+ }
+
+ anims.push(anim);
+ });
+
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.html.slideBy = function(/*DOMNode*/ nodes, /*Object*/ coords, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){
+ // summary: Returns an animation that will slide "nodes" from its current position
+ // to its current position plus the numbers defined in "coords".
+ // nodes: An array of DOMNodes or one DOMNode.
+ // coords: { top: Decimal?, left: Decimal? }
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+ var compute = dojo.html.getComputedStyle;
+
+ if(dojo.lang.isArray(coords)){
+ /* coords: Array
+ pId: a */
+ dojo.deprecated('dojo.lfx.html.slideBy(node, array)', 'use dojo.lfx.html.slideBy(node, {top: value, left: value});', '0.5');
+ coords = { top: coords[0], left: coords[1] };
+ }
+
+ dojo.lang.forEach(nodes, function(node){
+ var top = null;
+ var left = null;
+
+ var init = (function(){
+ var innerNode = node;
+ return function(){
+ var pos = compute(innerNode, 'position');
+ top = (pos == 'absolute' ? node.offsetTop : parseInt(compute(node, 'top')) || 0);
+ left = (pos == 'absolute' ? node.offsetLeft : parseInt(compute(node, 'left')) || 0);
+
+ if (!dojo.lang.inArray(['absolute', 'relative'], pos)) {
+ var ret = dojo.html.abs(innerNode, true);
+ dojo.html.setStyleAttributes(innerNode, "position:absolute;top:"+ret.y+"px;left:"+ret.x+"px;");
+ top = ret.y;
+ left = ret.x;
+ }
+ }
+ })();
+ init();
+
+ var anim = dojo.lfx.propertyAnimation(node,
+ {
+ "top": { start: top, end: top+(coords.top||0) },
+ "left": { start: left, end: left+(coords.left||0) }
+ },
+ duration,
+ easing).connect("beforeBegin", init);
+
+ if(callback){
+ anim.connect("onEnd", function(){ callback(nodes, anim); });
+ }
+
+ anims.push(anim);
+ });
+
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.html.explode = function(/*DOMNode*/ start,
+ /*DOMNode*/ endNode,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will
+ // start:
+ // endNode:
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ var h = dojo.html;
+ start = dojo.byId(start);
+ endNode = dojo.byId(endNode);
+ var startCoords = h.toCoordinateObject(start, true);
+ var outline = document.createElement("div");
+ h.copyStyle(outline, endNode);
+ if (endNode.explodeClassName) { outline.className = endNode.explodeClassName; }
+ with(outline.style){
+ position = "absolute";
+ display = "none";
+ // border = "1px solid black";
+ }
+ dojo.body().appendChild(outline);
+
+ with(endNode.style){
+ visibility = "hidden";
+ display = "block";
+ }
+ var endCoords = h.toCoordinateObject(endNode, true);
+ with(endNode.style){
+ display = "none";
+ visibility = "visible";
+ }
+
+ var props = { opacity: { start: 0.5, end: 1.0 } };
+ dojo.lang.forEach(["height", "width", "top", "left"], function(type){
+ props[type] = { start: startCoords[type], end: endCoords[type] }
+ });
+
+ var anim = new dojo.lfx.propertyAnimation(outline,
+ props,
+ duration,
+ easing,
+ {
+ "beforeBegin": function(){
+ h.setDisplay(outline, "block");
+ },
+ "onEnd": function(){
+ h.setDisplay(endNode, "block");
+ outline.parentNode.removeChild(outline);
+ }
+ }
+ );
+
+ if(callback){
+ anim.connect("onEnd", function(){ callback(endNode, anim); });
+ }
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html.implode = function(/*DOMNode*/ startNode,
+ /*DOMNode*/ end,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will
+ // startNode:
+ // end:
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ var h = dojo.html;
+ startNode = dojo.byId(startNode);
+ end = dojo.byId(end);
+ var startCoords = dojo.html.toCoordinateObject(startNode, true);
+ var endCoords = dojo.html.toCoordinateObject(end, true);
+
+ var outline = document.createElement("div");
+ dojo.html.copyStyle(outline, startNode);
+ if (startNode.explodeClassName) { outline.className = startNode.explodeClassName; }
+ dojo.html.setOpacity(outline, 0.3);
+ with(outline.style){
+ position = "absolute";
+ display = "none";
+ backgroundColor = h.getStyle(startNode, "background-color").toLowerCase();
+ }
+ dojo.body().appendChild(outline);
+
+ var props = { opacity: { start: 1.0, end: 0.5 } };
+ dojo.lang.forEach(["height", "width", "top", "left"], function(type){
+ props[type] = { start: startCoords[type], end: endCoords[type] }
+ });
+
+ var anim = new dojo.lfx.propertyAnimation(outline,
+ props,
+ duration,
+ easing,
+ {
+ "beforeBegin": function(){
+ dojo.html.hide(startNode);
+ dojo.html.show(outline);
+ },
+ "onEnd": function(){
+ outline.parentNode.removeChild(outline);
+ }
+ }
+ );
+
+ if(callback){
+ anim.connect("onEnd", function(){ callback(startNode, anim); });
+ }
+ return anim; // dojo.lfx.Animation
+}
+
+dojo.lfx.html.highlight = function(/*DOMNode[]*/ nodes,
+ /*dojo.gfx.color.Color*/ startColor,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will set the background color
+ // of "nodes" to startColor and transition it to "nodes"
+ // original color.
+ // startColor: Color to transition from.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+
+ dojo.lang.forEach(nodes, function(node){
+ var color = dojo.html.getBackgroundColor(node);
+ var bg = dojo.html.getStyle(node, "background-color").toLowerCase();
+ var bgImage = dojo.html.getStyle(node, "background-image");
+ var wasTransparent = (bg == "transparent" || bg == "rgba(0, 0, 0, 0)");
+ while(color.length > 3) { color.pop(); }
+
+ var rgb = new dojo.gfx.color.Color(startColor);
+ var endRgb = new dojo.gfx.color.Color(color);
+
+ var anim = dojo.lfx.propertyAnimation(node,
+ { "background-color": { start: rgb, end: endRgb } },
+ duration,
+ easing,
+ {
+ "beforeBegin": function(){
+ if(bgImage){
+ node.style.backgroundImage = "none";
+ }
+ node.style.backgroundColor = "rgb(" + rgb.toRgb().join(",") + ")";
+ },
+ "onEnd": function(){
+ if(bgImage){
+ node.style.backgroundImage = bgImage;
+ }
+ if(wasTransparent){
+ node.style.backgroundColor = "transparent";
+ }
+ if(callback){
+ callback(node, anim);
+ }
+ }
+ }
+ );
+
+ anims.push(anim);
+ });
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lfx.html.unhighlight = function(/*DOMNode[]*/ nodes,
+ /*dojo.gfx.color.Color*/ endColor,
+ /*int?*/ duration,
+ /*Function?*/ easing,
+ /*Function?*/ callback){
+ // summary: Returns an animation that will transition "nodes" background color
+ // from its current color to "endColor".
+ // endColor: Color to transition to.
+ // duration: Duration of the animation in milliseconds.
+ // easing: An easing function.
+ // callback: Function to run at the end of the animation.
+ nodes = dojo.lfx.html._byId(nodes);
+ var anims = [];
+
+ dojo.lang.forEach(nodes, function(node){
+ var color = new dojo.gfx.color.Color(dojo.html.getBackgroundColor(node));
+ var rgb = new dojo.gfx.color.Color(endColor);
+
+ var bgImage = dojo.html.getStyle(node, "background-image");
+
+ var anim = dojo.lfx.propertyAnimation(node,
+ { "background-color": { start: color, end: rgb } },
+ duration,
+ easing,
+ {
+ "beforeBegin": function(){
+ if(bgImage){
+ node.style.backgroundImage = "none";
+ }
+ node.style.backgroundColor = "rgb(" + color.toRgb().join(",") + ")";
+ },
+ "onEnd": function(){
+ if(callback){
+ callback(node, anim);
+ }
+ }
+ }
+ );
+ anims.push(anim);
+ });
+ return dojo.lfx.combine(anims); // dojo.lfx.Combine
+}
+
+dojo.lang.mixin(dojo.lfx, dojo.lfx.html);
+
+dojo.provide("dojo.lfx.*");
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/flash6_gateway.swf
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/Attic/flash6_gateway.swf,v
diff -u
Binary files differ
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/iframe_history.html
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/Attic/iframe_history.html,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/iframe_history.html 6 Nov 2006 14:37:19 -0000 1.1
@@ -0,0 +1,54 @@
+
+
+
+
+
+
+
+
+
+ The Dojo Toolkit -- iframe_history.html
+
+ This file is used in Dojo's back/fwd button management.
+
+
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/storage_dialog.swf
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/Attic/storage_dialog.swf,v
diff -u
Binary files differ
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/AdapterRegistry.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/AdapterRegistry.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/AdapterRegistry.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,89 @@
+/*
+ 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.AdapterRegistry");
+dojo.require("dojo.lang.func");
+
+dojo.AdapterRegistry = function(/*boolean, optional*/returnWrappers){
+ // summary:
+ // A registry to make contextual calling/searching easier.
+ // description:
+ // Objects of this class keep list of arrays in the form [name, check,
+ // wrap, directReturn] that are used to determine what the contextual
+ // result of a set of checked arguments is. All check/wrap functions
+ // in this registry should be of the same arity.
+ this.pairs = [];
+ this.returnWrappers = returnWrappers || false;
+}
+
+dojo.lang.extend(dojo.AdapterRegistry, {
+ register: function( /*string*/ name, /*function*/ check, /*function*/ wrap,
+ /*boolean, optional*/ directReturn,
+ /*boolean, optional*/ override){
+ // summary:
+ // register a check function to determine if the wrap function or
+ // object gets selected
+ // name: a way to identify this matcher.
+ // check:
+ // a function that arguments are passed to from the adapter's
+ // match() function. The check function should return true if the
+ // given arguments are appropriate for the wrap function.
+ // directReturn:
+ // If directReturn is true, the value passed in for wrap will be
+ // returned instead of being called. Alternately, the
+ // AdapterRegistry can be set globally to "return not call" using
+ // the returnWrappers property. Either way, this behavior allows
+ // the registry to act as a "search" function instead of a
+ // function interception library.
+ // override:
+ // If override is given and true, the check function will be given
+ // highest priority. Otherwise, it will be the lowest priority
+ // adapter.
+
+ var type = (override) ? "unshift" : "push";
+ this.pairs[type]([name, check, wrap, directReturn]);
+ },
+
+ match: function(/* ... */){
+ // summary:
+ // Find an adapter for the given arguments. If no suitable adapter
+ // is found, throws an exception. match() accepts any number of
+ // arguments, all of which are passed to all matching functions
+ // from the registered pairs.
+ for(var i = 0; i < this.pairs.length; i++){
+ var pair = this.pairs[i];
+ if(pair[1].apply(this, arguments)){
+ if((pair[3])||(this.returnWrappers)){
+ return pair[2];
+ }else{
+ return pair[2].apply(this, arguments);
+ }
+ }
+ }
+ throw new Error("No match found");
+ // dojo.raise("No match found");
+ },
+
+ unregister: function(name){
+ // summary: Remove a named adapter from the registry
+
+ // FIXME: this is kind of a dumb way to handle this. On a large
+ // registry this will be slow-ish and we can use the name as a lookup
+ // should we choose to trade memory for speed.
+ for(var i = 0; i < this.pairs.length; i++){
+ var pair = this.pairs[i];
+ if(pair[0] == name){
+ this.pairs.splice(i, 1);
+ return true;
+ }
+ }
+ return false;
+ }
+});
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Deferred.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/Deferred.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Deferred.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,315 @@
+/*
+ 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.Deferred");
+dojo.require("dojo.lang.func");
+
+dojo.Deferred = function(/* optional */ canceller){
+ /*
+ NOTE: this namespace and documentation are imported wholesale
+ from MochiKit
+
+ Encapsulates a sequence of callbacks in response to a value that
+ may not yet be available. This is modeled after the Deferred class
+ from Twisted .
+
+ Why do we want this? JavaScript has no threads, and even if it did,
+ threads are hard. Deferreds are a way of abstracting non-blocking
+ events, such as the final response to an XMLHttpRequest.
+
+ The sequence of callbacks is internally represented as a list
+ of 2-tuples containing the callback/errback pair. For example,
+ the following call sequence::
+
+ var d = new Deferred();
+ d.addCallback(myCallback);
+ d.addErrback(myErrback);
+ d.addBoth(myBoth);
+ d.addCallbacks(myCallback, myErrback);
+
+ is translated into a Deferred with the following internal
+ representation::
+
+ [
+ [myCallback, null],
+ [null, myErrback],
+ [myBoth, myBoth],
+ [myCallback, myErrback]
+ ]
+
+ The Deferred also keeps track of its current status (fired).
+ Its status may be one of three things:
+
+ -1: no value yet (initial condition)
+ 0: success
+ 1: error
+
+ A Deferred will be in the error state if one of the following
+ three conditions are met:
+
+ 1. The result given to callback or errback is "instanceof" Error
+ 2. The previous callback or errback raised an exception while
+ executing
+ 3. The previous callback or errback returned a value "instanceof"
+ Error
+
+ Otherwise, the Deferred will be in the success state. The state of
+ the Deferred determines the next element in the callback sequence to
+ run.
+
+ When a callback or errback occurs with the example deferred chain,
+ something equivalent to the following will happen (imagine that
+ exceptions are caught and returned)::
+
+ // d.callback(result) or d.errback(result)
+ if(!(result instanceof Error)){
+ result = myCallback(result);
+ }
+ if(result instanceof Error){
+ result = myErrback(result);
+ }
+ result = myBoth(result);
+ if(result instanceof Error){
+ result = myErrback(result);
+ }else{
+ result = myCallback(result);
+ }
+
+ The result is then stored away in case another step is added to the
+ callback sequence. Since the Deferred already has a value available,
+ any new callbacks added will be called immediately.
+
+ There are two other "advanced" details about this implementation that
+ are useful:
+
+ Callbacks are allowed to return Deferred instances themselves, so you
+ can build complicated sequences of events with ease.
+
+ The creator of the Deferred may specify a canceller. The canceller
+ is a function that will be called if Deferred.cancel is called before
+ the Deferred fires. You can use this to implement clean aborting of
+ an XMLHttpRequest, etc. Note that cancel will fire the deferred with
+ a CancelledError (unless your canceller returns another kind of
+ error), so the errbacks should be prepared to handle that error for
+ cancellable Deferreds.
+
+ */
+
+ this.chain = [];
+ this.id = this._nextId();
+ this.fired = -1;
+ this.paused = 0;
+ this.results = [null, null];
+ this.canceller = canceller;
+ this.silentlyCancelled = false;
+};
+
+dojo.lang.extend(dojo.Deferred, {
+ getFunctionFromArgs: function(){
+ var a = arguments;
+ if((a[0])&&(!a[1])){
+ if(dojo.lang.isFunction(a[0])){
+ return a[0];
+ }else if(dojo.lang.isString(a[0])){
+ return dj_global[a[0]];
+ }
+ }else if((a[0])&&(a[1])){
+ return dojo.lang.hitch(a[0], a[1]);
+ }
+ return null;
+ },
+
+ makeCalled: function() {
+ var deferred = new dojo.Deferred();
+ deferred.callback();
+ return deferred;
+ },
+
+ repr: function(){
+ var state;
+ if(this.fired == -1){
+ state = 'unfired';
+ }else if(this.fired == 0){
+ state = 'success';
+ } else {
+ state = 'error';
+ }
+ return 'Deferred(' + this.id + ', ' + state + ')';
+ },
+
+ toString: dojo.lang.forward("repr"),
+
+ _nextId: (function(){
+ var n = 1;
+ return function(){ return n++; };
+ })(),
+
+ cancel: function(){
+ /***
+ Cancels a Deferred that has not yet received a value, or is
+ waiting on another Deferred as its value.
+
+ If a canceller is defined, the canceller is called. If the
+ canceller did not return an error, or there was no canceller,
+ then the errback chain is started with CancelledError.
+ ***/
+ if(this.fired == -1){
+ if (this.canceller){
+ this.canceller(this);
+ }else{
+ this.silentlyCancelled = true;
+ }
+ if(this.fired == -1){
+ this.errback(new Error(this.repr()));
+ }
+ }else if( (this.fired == 0)&&
+ (this.results[0] instanceof dojo.Deferred)){
+ this.results[0].cancel();
+ }
+ },
+
+
+ _pause: function(){
+ // Used internally to signal that it's waiting on another Deferred
+ this.paused++;
+ },
+
+ _unpause: function(){
+ // Used internally to signal that it's no longer waiting on
+ // another Deferred.
+ this.paused--;
+ if ((this.paused == 0) && (this.fired >= 0)) {
+ this._fire();
+ }
+ },
+
+ _continue: function(res){
+ // Used internally when a dependent deferred fires.
+ this._resback(res);
+ this._unpause();
+ },
+
+ _resback: function(res){
+ // The primitive that means either callback or errback
+ this.fired = ((res instanceof Error) ? 1 : 0);
+ this.results[this.fired] = res;
+ this._fire();
+ },
+
+ _check: function(){
+ if(this.fired != -1){
+ if(!this.silentlyCancelled){
+ dojo.raise("already called!");
+ }
+ this.silentlyCancelled = false;
+ return;
+ }
+ },
+
+ callback: function(res){
+ /*
+ Begin the callback sequence with a non-error value.
+
+ callback or errback should only be called once on a given
+ Deferred.
+ */
+ this._check();
+ this._resback(res);
+ },
+
+ errback: function(res){
+ // Begin the callback sequence with an error result.
+ this._check();
+ if(!(res instanceof Error)){
+ res = new Error(res);
+ }
+ this._resback(res);
+ },
+
+ addBoth: function(cb, cbfn){
+ /*
+ Add the same function as both a callback and an errback as the
+ next element on the callback sequence. This is useful for code
+ that you want to guarantee to run, e.g. a finalizer.
+ */
+ var enclosed = this.getFunctionFromArgs(cb, cbfn);
+ if(arguments.length > 2){
+ enclosed = dojo.lang.curryArguments(null, enclosed, arguments, 2);
+ }
+ return this.addCallbacks(enclosed, enclosed);
+ },
+
+ addCallback: function(cb, cbfn){
+ // Add a single callback to the end of the callback sequence.
+ var enclosed = this.getFunctionFromArgs(cb, cbfn);
+ if(arguments.length > 2){
+ enclosed = dojo.lang.curryArguments(null, enclosed, arguments, 2);
+ }
+ return this.addCallbacks(enclosed, null);
+ },
+
+ addErrback: function(cb, cbfn){
+ // Add a single callback to the end of the callback sequence.
+ var enclosed = this.getFunctionFromArgs(cb, cbfn);
+ if(arguments.length > 2){
+ enclosed = dojo.lang.curryArguments(null, enclosed, arguments, 2);
+ }
+ return this.addCallbacks(null, enclosed);
+ return this.addCallbacks(null, cbfn);
+ },
+
+ addCallbacks: function (cb, eb) {
+ // Add separate callback and errback to the end of the callback
+ // sequence.
+ this.chain.push([cb, eb])
+ if (this.fired >= 0) {
+ this._fire();
+ }
+ return this;
+ },
+
+ _fire: function(){
+ // Used internally to exhaust the callback sequence when a result
+ // is available.
+ var chain = this.chain;
+ var fired = this.fired;
+ var res = this.results[fired];
+ var self = this;
+ var cb = null;
+ while (chain.length > 0 && this.paused == 0) {
+ // Array
+ var pair = chain.shift();
+ var f = pair[fired];
+ if (f == null) {
+ continue;
+ }
+ try {
+ res = f(res);
+ fired = ((res instanceof Error) ? 1 : 0);
+ if(res instanceof dojo.Deferred) {
+ cb = function(res){
+ self._continue(res);
+ }
+ this._pause();
+ }
+ }catch(err){
+ fired = 1;
+ res = err;
+ }
+ }
+ this.fired = fired;
+ this.results[fired] = res;
+ if((cb)&&(this.paused)){
+ // this is for "tail recursion" in case the dependent
+ // deferred is already fired
+ res.addBoth(cb);
+ }
+ }
+});
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/DeferredList.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/DeferredList.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/DeferredList.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,88 @@
+/*
+ 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.require("dojo.Deferred");
+
+dojo.provide("dojo.DeferredList");
+
+
+dojo.DeferredList = function (list, /*bool?*/ fireOnOneCallback, /*bool?*/ fireOnOneErrback, /*bool?*/ consumeErrors, /*Function?*/ canceller) {
+ this.list = list;
+ this.resultList = new Array(this.list.length);
+
+ // Deferred init
+ this.chain = [];
+ this.id = this._nextId();
+ this.fired = -1;
+ this.paused = 0;
+ this.results = [null, null];
+ this.canceller = canceller;
+ this.silentlyCancelled = false;
+
+ if (this.list.length === 0 && !fireOnOneCallback) {
+ this.callback(this.resultList);
+ }
+
+ this.finishedCount = 0;
+ this.fireOnOneCallback = fireOnOneCallback;
+ this.fireOnOneErrback = fireOnOneErrback;
+ this.consumeErrors = consumeErrors;
+
+ var index = 0;
+
+ var _this = this;
+
+ dojo.lang.forEach(this.list, function(d) {
+ var _index = index;
+ //dojo.debug("add cb/errb index "+_index);
+ d.addCallback(function(r) { _this._cbDeferred(_index, true, r) });
+ d.addErrback(function(r) { _this._cbDeferred(_index, false, r) });
+ index++;
+ });
+
+};
+
+
+dojo.inherits(dojo.DeferredList, dojo.Deferred);
+
+dojo.lang.extend(dojo.DeferredList, {
+
+ _cbDeferred: function (index, succeeded, result) {
+ //dojo.debug("Fire "+index+" succ "+succeeded+" res "+result);
+ this.resultList[index] = [succeeded, result];
+ this.finishedCount += 1;
+ if (this.fired !== 0) {
+ if (succeeded && this.fireOnOneCallback) {
+ this.callback([index, result]);
+ } else if (!succeeded && this.fireOnOneErrback) {
+ this.errback(result);
+ } else if (this.finishedCount == this.list.length) {
+ this.callback(this.resultList);
+ }
+ }
+ if (!succeeded && this.consumeErrors) {
+ result = null;
+ }
+ return result;
+ },
+
+ gatherResults: function (deferredList) {
+ var d = new dojo.DeferredList(deferredList, false, true, false);
+ d.addCallback(function (results) {
+ var ret = [];
+ for (var i = 0; i < results.length; i++) {
+ ret.push(results[i][1]);
+ }
+ return ret;
+ });
+ return d;
+ }
+});
+
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/a11y.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/a11y.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/a11y.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,103 @@
+/*
+ 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.a11y");
+
+dojo.require("dojo.uri.*");
+dojo.require("dojo.html.common");
+
+dojo.a11y = {
+ // imgPath: String path to the test image for determining if images are displayed or not
+ // doAccessibleCheck: Boolean if true will perform check for need to create accessible widgets
+ // accessible: Boolean uninitialized when null (accessible check has not been performed)
+ // if true generate accessible widgets
+ imgPath:dojo.uri.dojoUri("src/widget/templates/images"),
+ doAccessibleCheck: true,
+ accessible: null,
+
+ checkAccessible: function(){
+ // summary:
+ // perform check for accessibility if accessibility checking is turned
+ // on and the accessibility test has not been performed yet
+ if(this.accessible === null){
+ this.accessible = false; //default
+ if(this.doAccessibleCheck == true){
+ this.accessible = this.testAccessible();
+ }
+ }
+ return this.accessible; /* Boolean */
+ },
+
+ testAccessible: function(){
+ // summary:
+ // Always perform the accessibility check to determine if high
+ // contrast mode is on or display of images are turned off. Currently only checks
+ // in IE and Mozilla.
+ this.accessible = false; //default
+ if (dojo.render.html.ie || dojo.render.html.mozilla){
+ var div = document.createElement("div");
+ //div.style.color="rgb(153,204,204)";
+ div.style.backgroundImage = "url(\"" + this.imgPath + "/tab_close.gif\")";
+ // must add to hierarchy before can view currentStyle below
+ dojo.body().appendChild(div);
+ // in FF and IE the value for the current background style of the added div
+ // will be "none" in high contrast mode
+ // in FF the return value will be url(invalid-url:) when running over http
+ var bkImg = null;
+ if (window.getComputedStyle ) {
+ var cStyle = getComputedStyle(div, "");
+ bkImg = cStyle.getPropertyValue("background-image");
+ }else{
+ bkImg = div.currentStyle.backgroundImage;
+ }
+ var bUseImgElem = false;
+ if (bkImg != null && (bkImg == "none" || bkImg == "url(invalid-url:)" )) {
+ this.accessible = true;
+ }
+ /*
+ if(this.accessible == false && document.images){
+ // test if images are off in IE
+ var testImg = new Image();
+ if(testImg.fileSize) {
+ testImg.src = this.imgPath + "/tab_close.gif";
+ if(testImg.fileSize < 0){
+ this.accessible = true;
+ }
+ }
+ }*/
+ dojo.body().removeChild(div);
+ }
+ return this.accessible; /* Boolean */
+ },
+
+ setCheckAccessible: function(/* Boolean */ bTest){
+ // summary:
+ // Set whether or not to check for accessibility mode. Default value
+ // of module is true - perform check for accessibility modes.
+ // bTest: Boolean - true to check; false to turn off checking
+ this.doAccessibleCheck = bTest;
+ },
+
+ setAccessibleMode: function(){
+ // summary:
+ // perform the accessibility check and sets the correct mode to load
+ // a11y widgets. Only runs if test for accessiiblity has not been performed yet.
+ // Call testAccessible() to force the test.
+ if (this.accessible === null){
+ if (this.checkAccessible()){
+ dojo.render.html.prefixes.unshift("a11y");
+ }
+ }
+ return this.accessible; /* Boolean */
+ }
+};
+
+//dojo.hostenv.modulesLoadedListeners.unshift(function() { dojo.a11y.setAccessibleMode(); });
+//dojo.event.connect("before", dojo.hostenv, "makeWidgets", dojo.a11y, "setAccessibleMode");
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/animation.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/animation.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/animation.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -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.animation");
+dojo.require("dojo.animation.Animation");
+
+dojo.deprecated("dojo.animation is slated for removal in 0.5; use dojo.lfx instead.", "0.5");
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/behavior.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/behavior.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/behavior.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,248 @@
+/*
+ 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.behavior");
+dojo.require("dojo.event.*");
+
+dojo.require("dojo.experimental");
+dojo.experimental("dojo.behavior");
+
+dojo.behavior = new function(){
+ function arrIn(obj, name){
+ if(!obj[name]){ obj[name] = []; }
+ return obj[name];
+ }
+
+ function forIn(obj, scope, func){
+ var tmpObj = {};
+ for(var x in obj){
+ if(typeof tmpObj[x] == "undefined"){
+ if(!func){
+ scope(obj[x], x);
+ }else{
+ func.call(scope, obj[x], x);
+ }
+ }
+ }
+ }
+
+ // FIXME: need a better test so we don't exclude nightly Safari's!
+ this.behaviors = {};
+ this.add = function(behaviorObj){
+ /* behavior objects are specified in the following format:
+ *
+ * {
+ * "#id": {
+ * "found": function(element){
+ * // ...
+ * },
+ *
+ * "onblah": {targetObj: foo, targetFunc: "bar"},
+ *
+ * "onblarg": "/foo/bar/baz/blarg",
+ *
+ * "onevent": function(evt){
+ * },
+ *
+ * "onotherevent: function(evt){
+ * // ...
+ * }
+ * },
+ *
+ * "#id2": {
+ * // ...
+ * },
+ *
+ * "#id3": function(element){
+ * // ...
+ * },
+ *
+ * // publish the match on a topic
+ * "#id4": "/found/topic/name",
+ *
+ * // match all direct descendants
+ * "#id4 > *": function(element){
+ * // ...
+ * },
+ *
+ * // match the first child node that's an element
+ * "#id4 > @firstElement": { ... },
+ *
+ * // match the last child node that's an element
+ * "#id4 > @lastElement": { ... },
+ *
+ * // all elements of type tagname
+ * "tagname": {
+ * // ...
+ * },
+ *
+ * // maps to roughly:
+ * // dojo.lang.forEach(body.getElementsByTagName("tagname1"), function(node){
+ * // dojo.lang.forEach(node.getElementsByTagName("tagname2"), function(node2){
+ * // dojo.lang.forEach(node2.getElementsByTagName("tagname3", function(node3){
+ * // // apply rules
+ * // });
+ * // });
+ * // });
+ * "tagname1 tagname2 tagname3": {
+ * // ...
+ * },
+ *
+ * ".classname": {
+ * // ...
+ * },
+ *
+ * "tagname.classname": {
+ * // ...
+ * },
+ * }
+ *
+ * The "found" method is a generalized handler that's called as soon
+ * as the node matches the selector. Rules for values that follow also
+ * apply to the "found" key.
+ *
+ * The "on*" handlers are attached with dojo.event.connect(). If the
+ * value is not a function but is rather an object, it's assumed to be
+ * the "other half" of a dojo.event.kwConnect() argument object. It
+ * may contain any/all properties of such a connection modifier save
+ * for the sourceObj and sourceFunc properties which are filled in by
+ * the system automatically. If a string is instead encountered, the
+ * node publishes the specified event on the topic contained in the
+ * string value.
+ *
+ * If the value corresponding to the ID key is a function and not a
+ * list, it's treated as though it was the value of "found".
+ *
+ */
+
+ var tmpObj = {};
+ forIn(behaviorObj, this, function(behavior, name){
+ var tBehavior = arrIn(this.behaviors, name);
+ if((dojo.lang.isString(behavior))||(dojo.lang.isFunction(behavior))){
+ behavior = { found: behavior };
+ }
+ forIn(behavior, function(rule, ruleName){
+ arrIn(tBehavior, ruleName).push(rule);
+ });
+ });
+ }
+
+ this.apply = function(){
+ dojo.profile.start("dojo.behavior.apply");
+ var r = dojo.render.html;
+ // note, we apply one way for fast queries and one way for slow
+ // iteration. So be it.
+ var safariGoodEnough = (!r.safari);
+ if(r.safari){
+ // Anything over release #420 should work the fast way
+ var uas = r.UA.split("AppleWebKit/")[1];
+ if(parseInt(uas.match(/[0-9.]{3,}/)) >= 420){
+ safariGoodEnough = true;
+ }
+ }
+ if((dj_undef("behaviorFastParse", djConfig) ? (safariGoodEnough) : djConfig["behaviorFastParse"])){
+ this.applyFast();
+ }else{
+ this.applySlow();
+ }
+ dojo.profile.end("dojo.behavior.apply");
+ }
+
+ this.matchCache = {};
+
+ this.elementsById = function(id, handleRemoved){
+ var removed = [];
+ var added = [];
+ arrIn(this.matchCache, id);
+ if(handleRemoved){
+ var nodes = this.matchCache[id];
+ for(var x=0; x");
+ } catch (e) {
+ var script = document.createElement("script");
+ script.src = spath;
+ document.getElementsByTagName("head")[0].appendChild(script);
+ }
+ }
+ }
+})();
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/browser_debug.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/browser_debug.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/browser_debug.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,176 @@
+/*
+ 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.hostenv.loadedUris.push("../src/bootstrap1.js");
+dojo.hostenv.loadedUris.push("../src/loader.js");
+dojo.hostenv.loadedUris.push("../src/hostenv_browser.js");
+dojo.hostenv.loadedUris.push("../src/bootstrap2.js");
+dojo.hostenv._loadedUrisListStart = dojo.hostenv.loadedUris.length;
+
+function removeComments(contents){
+ contents = new String((!contents) ? "" : contents);
+ // clobber all comments
+ // FIXME broken if // or /* inside quotes or regexp
+ contents = contents.replace( /^(.*?)\/\/(.*)$/mg , "$1");
+ contents = contents.replace( /(\n)/mg , "__DOJONEWLINE");
+ contents = contents.replace( /\/\*(.*?)\*\//g , "");
+ return contents.replace( /__DOJONEWLINE/mg , "\n");
+}
+
+dojo.hostenv.getRequiresAndProvides = function(contents){
+ // FIXME: should probably memoize this!
+ if(!contents){ return []; }
+
+
+ // check to see if we need to load anything else first. Ugg.
+ var deps = [];
+ var tmp;
+ RegExp.lastIndex = 0;
+ var testExp = /dojo.(hostenv.loadModule|hostenv.require|require|requireIf|kwCompoundRequire|hostenv.conditionalLoadModule|hostenv.startPackage|provide)\([\w\W]*?\)/mg;
+ while((tmp = testExp.exec(contents)) != null){
+ deps.push(tmp[0]);
+ }
+ return deps;
+}
+
+dojo.hostenv.getDelayRequiresAndProvides = function(contents){
+ // FIXME: should probably memoize this!
+ if(!contents){ return []; }
+
+ // check to see if we need to load anything else first. Ugg.
+ var deps = [];
+ var tmp;
+ RegExp.lastIndex = 0;
+ var testExp = /dojo.(requireAfterIf)\([\w\W]*?\)/mg;
+ while((tmp = testExp.exec(contents)) != null){
+ deps.push(tmp[0]);
+ }
+ return deps;
+}
+
+/*
+dojo.getNonExistantDescendants = function(objpath){
+ var ret = [];
+ // fast path for no periods
+ if(typeof objpath != "string"){ return dj_global; }
+ if(objpath.indexOf('.') == -1){
+ if(dj_undef(objpath, dj_global)){
+ ret.push[objpath];
+ }
+ return ret;
+ }
+
+ var syms = objpath.split(/\./);
+ var obj = dj_global;
+ for(var i=0;i=0; x--){
+ dojo.clobberLastObject(removals[x]);
+ }
+ var depList = [];
+ var seen = dojo.hostenv._writtenIncludes;
+ for(var x=0; x");
+ }
+ document.write("");
+ dojo.hostenv._loadedUrisListStart = 0;
+ if (!willCallAgain) {
+ // turn off debugAtAllCosts, so that dojo.require() calls inside of ContentPane hrefs
+ // work correctly
+ dj_eval = old_dj_eval;
+ dojo.hostenv.loadUri = dojo.hostenv.oldLoadUri;
+ }
+}
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/crypto.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/crypto.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/crypto.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,31 @@
+/*
+ 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.crypto");
+
+dojo.crypto.cipherModes={
+ // summary
+ // Enumeration for various cipher modes.
+ ECB:0,
+ CBC:1,
+ PCBC:2,
+ CFB:3,
+ OFB:4,
+ CTR:5
+};
+
+dojo.crypto.outputTypes={
+ // summary
+ // Enumeration for input and output encodings.
+ Base64:0,
+ Hex:1,
+ String:2,
+ Raw:3
+};
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/data.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/data.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/data.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,15 @@
+/*
+ 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.data");
+
+// currently a stub for dojo.data
+
+dojo.data = {};
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/date.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/date.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/date.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,13 @@
+/*
+ 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.date");
+
+dojo.deprecated("dojo.date", "use one of the modules in dojo.date.* instead", "0.5");
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/debug.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/debug.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/debug.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,91 @@
+/*
+ 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.debug = function(/*...*/){
+ // summary:
+ // Produce a line of debug output. Does nothing unless
+ // djConfig.isDebug is true. Accepts any nubmer of args, joined with
+ // '' to produce a single line of debugging output. Caller should not
+ // supply a trailing "\n".
+ if (!djConfig.isDebug) { return; }
+ var args = arguments;
+ if(dj_undef("println", dojo.hostenv)){
+ dojo.raise("dojo.debug not available (yet?)");
+ }
+ var isJUM = dj_global["jum"] && !dj_global["jum"].isBrowser;
+ var s = [(isJUM ? "": "DEBUG: ")];
+ for(var i=0;i 1){
+ args.url = [args.url, dirs[1]].join(".");
+ }
+ }
+ }
+ }
+
+ dojo.io.bind(args);
+ return deferred;
+ },
+ getFunctionNames: function(){
+ return this.require("function_names"); // dojo.Deferred
+ },
+ unFormat: function(/*String*/ string){
+ var fString = string;
+ if(string.charAt(string.length - 1) == "_"){
+ fString = [string.substring(0, string.length - 1), "*"].join("");
+ }
+ return fString;
+ },
+ getMeta: function(/*mixed*/ selectKey, /*String*/ pkg, /*String*/ name, /*Function*/ callback, /*String?*/ id){
+ // summary: Gets information about a function in regards to its meta data
+ if(typeof name == "function"){
+ // pId: a
+ // pkg: ignore
+ id = callback;
+ callback = name;
+ name = pkg;
+ pkg = null;
+ dojo.debug("getMeta(" + name + ")");
+ }else{
+ dojo.debug("getMeta(" + pkg + "/" + name + ")");
+ }
+
+ if(!id){
+ id = "_";
+ }
+
+ if(!selectKey){
+ selectKey = ++dojo.docs._count;
+ }
+
+ var input;
+ if(typeof selectKey == "object" && selectKey.selectKey){
+ input = selectKey;
+ selectKey = selectKey.selectKey;
+ }else{
+ input = {};
+ }
+
+ dojo.docs._buildCache({
+ type: "meta",
+ callbacks: [dojo.docs._gotMeta, callback],
+ pkg: pkg,
+ name: name,
+ id: id,
+ selectKey: selectKey,
+ input: input
+ });
+ },
+ _withPkg: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input, /*String*/ newType){
+ dojo.debug("_withPkg(" + evt.name + ") has package: " + data[0]);
+ evt.pkg = data[0];
+ if("load" == type && evt.pkg){
+ evt.type = newType;
+ dojo.docs._buildCache(evt);
+ }else{
+ if(evt.callbacks && evt.callbacks.length){
+ evt.callbacks.shift()("error", {}, evt, evt.input);
+ }
+ }
+ },
+ _gotMeta: function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+ dojo.debug("_gotMeta(" + evt.name + ")");
+
+ var cached = dojo.docs._getCache(evt.pkg, evt.name, "meta", "functions", evt.id);
+ if(cached.summary){
+ data.summary = cached.summary;
+ }
+ if(evt.callbacks && evt.callbacks.length){
+ evt.callbacks.shift()(type, data, evt, evt.input);
+ }
+ },
+ getSrc: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback, /*String?*/ id){
+ // summary: Gets src file (created by the doc parser)
+ dojo.debug("getSrc(" + name + ")");
+ if(!id){
+ id = "_";
+ }
+ if(!selectKey){
+ selectKey = ++dojo.docs._count;
+ }
+
+ var input;
+ if(typeof selectKey == "object" && selectKey.selectKey){
+ input = selectKey;
+ selectKey = selectKey.selectKey;
+ }else{
+ input = {};
+ }
+
+ dojo.docs._buildCache({
+ type: "src",
+ callbacks: [callback],
+ name: name,
+ id: id,
+ input: input,
+ selectKey: selectKey
+ });
+ },
+ getDoc: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback, /*String?*/ id){
+ // summary: Gets external documentation stored on Jot for a given function
+ dojo.debug("getDoc(" + name + ")");
+
+ if(!id){
+ id = "_";
+ }
+
+ if(!selectKey){
+ selectKey = ++dojo.docs._count;
+ }
+
+ var input = {};
+ if(typeof selectKey == "object" && selectKey.selectKey){
+ input.input = selectKey;
+ selectKey = selectKey.selectKey;
+ }
+
+ input.type = "doc";
+ input.name = name;
+ input.selectKey = selectKey;
+ input.callbacks = [callback];
+ input.selectKey = selectKey;
+
+ dojo.docs._buildCache(input);
+ },
+ _gotDoc: function(/*String*/ type, /*Array*/ data, /*Object*/ evt, /*Object*/ input){
+ dojo.debug("_gotDoc(" + evt.type + ")");
+
+ evt[evt.type] = data;
+ if(evt.expects && evt.expects.doc){
+ for(var i = 0, expect; expect = evt.expects.doc[i]; i++){
+ if(!(expect in evt)){
+ dojo.debug("_gotDoc() waiting for more data");
+ return;
+ }
+ }
+ }
+
+ var cache = dojo.docs._getCache(evt.pkg, "meta", "functions", evt.name, evt.id, "meta");
+
+ var description = evt.fn.description;
+ cache.description = description;
+ data = {
+ returns: evt.fn.returns,
+ id: evt.id,
+ variables: [],
+ selectKey: evt.selectKey
+ }
+ if(!cache.parameters){
+ cache.parameters = {};
+ }
+ for(var i = 0, param; param = evt.param[i]; i++){
+ var fName = param["DocParamForm/name"];
+ if(!cache.parameters[fName]){
+ cache.parameters[fName] = {};
+ }
+ cache.parameters[fName].description = param["DocParamForm/desc"]
+ }
+
+ data.description = cache.description;
+ data.parameters = cache.parameters;
+
+ evt.type = "doc";
+
+ if(evt.callbacks && evt.callbacks.length){
+ evt.callbacks.shift()("load", data, evt, input);
+ }
+ },
+ getPkgDoc: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback){
+ // summary: Gets external documentation stored on Jot for a given package
+ dojo.debug("getPkgDoc(" + name + ")");
+ var input = {};
+ if(typeof selectKey == "object" && selectKey.selectKey){
+ input = selectKey;
+ selectKey = selectKey.selectKey;
+ }
+ if(!selectKey){
+ selectKey = ++dojo.docs._count;
+ }
+ dojo.docs._buildCache({
+ type: "pkgdoc",
+ callbacks: [callback],
+ name: name,
+ selectKey: selectKey,
+ input: input
+ });
+ },
+ getPkgInfo: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback){
+ // summary: Gets a combination of the metadata and external documentation for a given package
+ dojo.debug("getPkgInfo(" + name + ")");
+ if(!selectKey){
+ selectKey = ++dojo.docs._count;
+ }
+
+ var input = {
+ selectKey: selectKey,
+ expects: {
+ pkginfo: ["pkgmeta", "pkgdoc"]
+ },
+ callback: callback
+ };
+ dojo.docs.getPkgMeta(input, name, dojo.docs._getPkgInfo);
+ dojo.docs.getPkgDoc(input, name, dojo.docs._getPkgInfo);
+ },
+ _getPkgInfo: function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+ dojo.debug("_getPkgInfo() for " + evt.type);
+ var key = evt.selectKey;
+ var input = {};
+ var results = {};
+ if(typeof key == "object"){
+ input = key;
+ key = key.selectKey;
+ input[evt.type] = data;
+ if(input.expects && input.expects.pkginfo){
+ for(var i = 0, expect; expect = input.expects.pkginfo[i]; i++){
+ if(!(expect in input)){
+ dojo.debug("_getPkgInfo() waiting for more data");
+ return;
+ }
+ }
+ }
+ results = input.pkgmeta;
+ results.description = input.pkgdoc;
+ }
+
+ if(input.callback){
+ input.callback("load", results, evt);
+ }
+ },
+ getInfo: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback){
+ dojo.debug("getInfo(" + name + ")");
+ var input = {
+ expects: {
+ "info": ["meta", "doc"]
+ },
+ selectKey: selectKey,
+ callback: callback
+ }
+ dojo.docs.getMeta(input, name, dojo.docs._getInfo);
+ dojo.docs.getDoc(input, name, dojo.docs._getInfo);
+ },
+ _getInfo: function(/*String*/ type, /*String*/ data, /*Object*/ evt, /*Object*/ input){
+ dojo.debug("_getInfo(" + evt.type + ")");
+ if(input && input.expects && input.expects.info){
+ input[evt.type] = data;
+ for(var i = 0, expect; expect = input.expects.info[i]; i++){
+ if(!(expect in input)){
+ dojo.debug("_getInfo() waiting for more data");
+ return;
+ }
+ }
+ }
+
+ if(input.callback){
+ input.callback("load", dojo.docs._getCache(evt.pkg, "meta", "functions", evt.name, evt.id, "meta"), evt, input);
+ }
+ },
+ _getMainText: function(/*String*/ text){
+ // summary: Grabs the innerHTML from a Jot Rech Text node
+ dojo.debug("_getMainText()");
+ return text.replace(/^/, "").replace(/<\/html>$/, "").replace(/<\w+\s*\/>/g, "");
+ },
+ getPackageMeta: function(/*Object*/ input){
+ dojo.debug("getPackageMeta(): " + input.pkg);
+ return this.require(input.pkg + "/meta", input.sync);
+ },
+ OLDgetPkgMeta: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback){
+ dojo.debug("getPkgMeta(" + name + ")");
+ var input = {};
+ if(typeof selectKey == "object" && selectKey.selectKey){
+ input = selectKey;
+ selectKey = selectKey.selectKey;
+ }else if(!selectKey){
+ selectKey = ++dojo.docs._count;
+ }
+ dojo.docs._buildCache({
+ type: "pkgmeta",
+ callbacks: [callback],
+ name: name,
+ selectKey: selectKey,
+ input: input
+ });
+ },
+ OLD_getPkgMeta: function(/*Object*/ input){
+ dojo.debug("_getPkgMeta(" + input.name + ")");
+ input.type = "pkgmeta";
+ dojo.docs._buildCache(input);
+ },
+ _onDocSearch: function(/*Object*/ input){
+ var _this = this;
+ var name = input.name.toLowerCase();
+ if(!name) return;
+
+ this.getFunctionNames().addCallback(function(data){
+ dojo.debug("_onDocSearch(): function names loaded for " + name);
+
+ var output = [];
+ var list = [];
+ var closure = function(pkg, fn) {
+ return function(data){
+ dojo.debug("_onDocSearch(): package meta loaded for: " + pkg);
+ if(data.functions){
+ var functions = data.functions;
+ for(var key in functions){
+ if(fn == key){
+ var ids = functions[key];
+ for(var id in ids){
+ var fnMeta = ids[id];
+ output.push({
+ package: pkg,
+ name: fn,
+ id: id,
+ summary: fnMeta.summary
+ });
+ }
+ }
+ }
+ }
+ return output;
+ }
+ }
+
+ pkgLoop:
+ for(var pkg in data){
+ if(pkg.toLowerCase() == name){
+ name = pkg;
+ dojo.debug("_onDocSearch found a package");
+ //dojo.docs._onDocSelectPackage(input);
+ return;
+ }
+ for(var i = 0, fn; fn = data[pkg][i]; i++){
+ if(fn.toLowerCase().indexOf(name) != -1){
+ dojo.debug("_onDocSearch(): Search matched " + fn);
+ var meta = _this.getPackageMeta({pkg: pkg});
+ meta.addCallback(closure(pkg, fn));
+ list.push(meta);
+
+ // Build a list of all packages that need to be loaded and their loaded state.
+ continue pkgLoop;
+ }
+ }
+ }
+
+ list = new dojo.DeferredList(list);
+ list.addCallback(function(results){
+ dojo.debug("_onDocSearch(): All packages loaded");
+ _this._printFunctionResults(results[0][1]);
+ });
+ });
+ },
+ _onDocSearchFn: function(/*String*/ type, /*Array*/ data, /*Object*/ evt){
+ dojo.debug("_onDocSearchFn(" + evt.name + ")");
+
+ var name = evt.name || evt.pkg;
+
+ dojo.debug("_onDocSearchFn found a function");
+
+ evt.pkgs = packages;
+ evt.pkg = name;
+ evt.loaded = 0;
+ for(var i = 0, pkg; pkg = packages[i]; i++){
+ dojo.docs.getPkgMeta(evt, pkg, dojo.docs._onDocResults);
+ }
+ },
+ _onPkgResults: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input){
+ dojo.debug("_onPkgResults(" + evt.type + ")");
+ var description = "";
+ var path = "";
+ var methods = {};
+ var requires = {};
+ if(input){
+ input[evt.type] = data;
+ if(input.expects && input.expects.pkgresults){
+ for(var i = 0, expect; expect = input.expects.pkgresults[i]; i++){
+ if(!(expect in input)){
+ dojo.debug("_onPkgResults() waiting for more data");
+ return;
+ }
+ }
+ }
+ path = input.pkgdoc.path;
+ description = input.pkgdoc.description;
+ methods = input.pkgmeta.methods;
+ requires = input.pkgmeta.requires;
+ }
+ var pkg = evt.name.replace("_", "*");
+ var results = {
+ path: path,
+ description: description,
+ size: 0,
+ methods: [],
+ pkg: pkg,
+ selectKey: evt.selectKey,
+ requires: requires
+ }
+ var rePrivate = /_[^.]+$/;
+ for(var method in methods){
+ if(!rePrivate.test(method)){
+ for(var pId in methods[method]){
+ results.methods.push({
+ pkg: pkg,
+ name: method,
+ id: pId,
+ summary: methods[method][pId].summary
+ })
+ }
+ }
+ }
+ results.size = results.methods.length;
+ dojo.docs._printPkgResult(results);
+ },
+ _onDocResults: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input){
+ dojo.debug("_onDocResults(" + evt.name + "/" + input.pkg + ") " + type);
+ ++input.loaded;
+
+ if(input.loaded == input.pkgs.length){
+ var pkgs = input.pkgs;
+ var name = input.pkg;
+ var results = {selectKey: evt.selectKey, methods: []};
+ var rePrivate = /_[^.]+$/;
+ data = dojo.docs._cache;
+
+ for(var i = 0, pkg; pkg = pkgs[i]; i++){
+ var methods = dojo.docs._getCache(pkg, "meta", "methods");
+ for(var fn in methods){
+ if(fn.toLowerCase().indexOf(name) == -1){
+ continue;
+ }
+ if(fn != "requires" && !rePrivate.test(fn)){
+ for(var pId in methods[fn]){
+ var result = {
+ pkg: pkg,
+ name: fn,
+ id: "_",
+ summary: ""
+ }
+ if(methods[fn][pId].summary){
+ result.summary = methods[fn][pId].summary;
+ }
+ results.methods.push(result);
+ }
+ }
+ }
+ }
+
+ dojo.debug("Publishing docResults");
+ dojo.docs._printFnResults(results);
+ }
+ },
+ _printFunctionResults: function(results){
+ dojo.debug("_printFnResults(): called");
+ // summary: Call this function to send the /docs/function/results topic
+ },
+ _printPkgResult: function(results){
+ dojo.debug("_printPkgResult(): called");
+ },
+ _onDocSelectFunction: function(/*Object*/ input){
+ // summary: Get doc, meta, and src
+ var name = input.name;
+ var pkg = input.pkg;
+ dojo.debug("_onDocSelectFunction(" + name + ")");
+ if(!name){
+ return false;
+ }
+ if(!input.selectKey){
+ input.selectKey = ++dojo.docs._count;
+ }
+ input.expects = {
+ "docresults": ["meta", "doc", "pkgmeta"]
+ }
+ dojo.docs.getMeta(input, pkg, name, dojo.docs._onDocSelectResults);
+ dojo.docs.getDoc(input, pkg, name, dojo.docs._onDocSelectResults);
+ },
+ _onDocSelectPackage: function(/*Object*/ input){
+ dojo.debug("_onDocSelectPackage(" + input.name + ")")
+ input.expects = {
+ "pkgresults": ["pkgmeta", "pkgdoc"]
+ };
+ if(!input.selectKey){
+ input.selectKey = ++dojo.docs._count;
+ }
+ dojo.docs.getPkgMeta(input, input.name, dojo.docs._onPkgResults);
+ dojo.docs.getPkgDoc(input, input.name, dojo.docs._onPkgResults);
+ },
+ _onDocSelectResults: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input){
+ dojo.debug("_onDocSelectResults(" + evt.type + ", " + evt.name + ")");
+ if(evt.type == "meta"){
+ dojo.docs.getPkgMeta(input, evt.pkg, dojo.docs._onDocSelectResults);
+ }
+ if(input){
+ input[evt.type] = data;
+ if(input.expects && input.expects.docresults){
+ for(var i = 0, expect; expect = input.expects.docresults[i]; i++){
+ if(!(expect in input)){
+ dojo.debug("_onDocSelectResults() waiting for more data");
+ return;
+ }
+ }
+ }
+ }
+
+ dojo.docs._printFunctionDetail(input);
+ },
+
+ _printFunctionDetail: function(results) {
+ // summary: Call this function to send the /docs/function/detail topic event
+ },
+
+ _buildCache: function(/*Object*/ input){
+ dojo.debug("_buildCache(" + input.type + ", " + input.name + ")");
+ // Get stuff from the input object
+ var type = input.type;
+ var pkg = input.pkg;
+ var callbacks = input.callbacks;
+ var id = input.id;
+ if(!id){
+ id = input.id = "_";
+ }
+ var name = input.name;
+ var selectKey = input.selectKey;
+
+ var META = "meta";
+ var METHODS = "methods";
+ var SRC = "src";
+ var DESCRIPTION = "description";
+ var INPUT = "input";
+ var LOAD = "load";
+ var ERROR = "error";
+
+ var docs = dojo.docs;
+ var getCache = docs._getCache;
+
+ // Stuff to pass to RPC
+ var search = [];
+
+ if(type == "doc"){
+ if(!pkg){
+ docs.functionPackages(selectKey, name, function(){ var a = arguments; docs._withPkg.call(this, a[0], a[1], a[2], a[3], "doc"); }, input);
+ return;
+ }else{
+ var cached = getCache(pkg, META, METHODS, name, id, META);
+
+ if(cached[DESCRIPTION]){
+ callbacks.shift()(LOAD, cached[DESCRIPTION], input, input[INPUT]);
+ return;
+ }
+
+ var obj = {};
+ obj.forFormName = "DocFnForm";
+ obj.limit = 1;
+
+ obj.filter = "it/DocFnForm/require = '" + pkg + "' and it/DocFnForm/name = '" + name + "' and ";
+ if(id == "_"){
+ obj.filter += " not(it/DocFnForm/id)";
+ }else{
+ obj.filter += " it/DocFnForm/id = '" + id + "'";
+ }
+
+ obj.load = function(data){
+ var cached = getCache(pkg, META, METHODS, name, id, META);
+
+ var description = "";
+ var returns = "";
+ if(data.list && data.list.length){
+ description = docs._getMainText(data.list[0]["main/text"]);
+ returns = data.list[0]["DocFnForm/returns"];
+ }
+
+ cached[DESCRIPTION] = description;
+ if(!cached.returns){
+ cached.returns = {};
+ }
+ cached.returns.summary = returns;
+
+ input.type = "fn";
+ docs._gotDoc(LOAD, cached, input, input[INPUT]);
+ }
+ obj.error = function(data){
+ input.type = "fn";
+ docs._gotDoc(ERROR, {}, input, input[INPUT]);
+ }
+ search.push(obj);
+
+ obj = {};
+ obj.forFormName = "DocParamForm";
+
+ obj.filter = "it/DocParamForm/fns = '" + pkg + "=>" + name;
+ if(id != "_"){
+ obj.filter += "=>" + id;
+ }
+ obj.filter += "'";
+
+ obj.load = function(data){
+ var cache = getCache(pkg, META, METHODS, name, id, META);
+ for(var i = 0, param; param = data.list[i]; i++){
+ var pName = param["DocParamForm/name"];
+ if(!cache.parameters[pName]){
+ cache.parameters[pName] = {};
+ }
+ cache.parameters[pName].summary = param["DocParamForm/desc"];
+ }
+ input.type = "param";
+ docs._gotDoc(LOAD, cache.parameters, input);
+ }
+ obj.error = function(data){
+ input.type = "param";
+ docs._gotDoc(ERROR, {}, input);
+ }
+ search.push(obj);
+ }
+ }else if(type == "pkgdoc"){
+ var cached = getCache(name, META);
+
+ if(cached[DESCRIPTION]){
+ callbacks.shift()(LOAD, {description: cached[DESCRIPTION], path: cached.path}, input, input.input);
+ return;
+ }
+
+ var obj = {};
+ obj.forFormName = "DocPkgForm";
+ obj.limit = 1;
+ obj.filter = "it/DocPkgForm/require = '" + name + "'";
+
+ obj.load = function(data){
+ var description = "";
+ var list = data.list;
+ if(list && list.length && list[0]["main/text"]){
+ description = docs._getMainText(list[0]["main/text"]);
+ cached[DESCRIPTION] = description;
+ cached.path = list[0].name;
+ }
+
+ if(callbacks && callbacks.length){
+ callbacks.shift()(LOAD, {description: description, path: cached.path}, input, input.input);
+ }
+ }
+ obj.error = function(data){
+ if(callbacks && callbacks.length){
+ callbacks.shift()(ERROR, "", input, input.input);
+ }
+ }
+ search.push(obj);
+ }else if(type == "function_names"){
+ var cached = getCache();
+ if(!cached.function_names){
+ dojo.debug("_buildCache() new cache");
+ if(callbacks && callbacks.length){
+ docs._callbacks.function_names.push([input, callbacks.shift()]);
+ }
+ cached.function_names = {loading: true};
+
+ var obj = {};
+ obj.url = "function_names";
+ obj.load = function(type, data, evt){
+ cached.function_names = data;
+ while(docs._callbacks.function_names.length){
+ var parts = docs._callbacks.function_names.pop();
+ parts[1](LOAD, data, parts[0]);
+ }
+ }
+ obj.error = function(type, data, evt){
+ while(docs._callbacks.function_names.length){
+ var parts = docs._callbacks.function_names.pop();
+ parts[1](LOAD, {}, parts[0]);
+ }
+ }
+ search.push(obj);
+ }else if(cached.function_names.loading){
+ dojo.debug("_buildCache() loading cache, adding to callback list");
+ if(callbacks && callbacks.length){
+ docs._callbacks.function_names.push([input, callbacks.shift()]);
+ }
+ return;
+ }else{
+ dojo.debug("_buildCache() loading from cache");
+ if(callbacks && callbacks.length){
+ callbacks.shift()(LOAD, cached.function_names, input);
+ }
+ return;
+ }
+ }else if(type == META || type == SRC){
+ if(!pkg){
+ if(type == META){
+ docs.functionPackages(selectKey, name, function(){ var a = arguments; docs._withPkg.call(this, a[0], a[1], a[2], a[3], META); }, input);
+ return;
+ }else{
+ docs.functionPackages(selectKey, name, function(){ var a = arguments; docs._withPkg.call(this, a[0], a[1], a[2], a[3], SRC); }, input);
+ return;
+ }
+ }else{
+ var cached = getCache(pkg, META, METHODS, name, id);
+
+ if(cached[type] && cached[type].returns){
+ if(callbacks && callbacks.length){
+ callbacks.shift()(LOAD, cached[type], input);
+ return;
+ }
+ }
+
+ dojo.debug("Finding " + type + " for: " + pkg + ", function: " + name + ", id: " + id);
+
+ var obj = {};
+
+ if(type == SRC){
+ obj.mimetype = "text/plain"
+ }
+ obj.url = pkg + "/" + name + "/" + id + "/" + type;
+ obj.load = function(type, data, evt){
+ dojo.debug("_buildCache() loaded " + input.type);
+
+ if(input.type == SRC){
+ getCache(pkg, META, METHODS, name, id).src = data;
+ if(callbacks && callbacks.length){
+ callbacks.shift()(LOAD, data, input, input[INPUT]);
+ }
+ }else{
+ var cache = getCache(pkg, META, METHODS, name, id, META);
+ if(!cache.parameters){
+ cache.parameters = {};
+ }
+ for(var i = 0, param; param = data.parameters[i]; i++){
+ if(!cache.parameters[param[1]]){
+ cache.parameters[param[1]] = {};
+ }
+ cache.parameters[param[1]].type = param[0];
+ }
+ if(!cache.returns){
+ cache.returns = {};
+ }
+ cache.returns.type = data.returns;
+ }
+
+ if(callbacks && callbacks.length){
+ callbacks.shift()(LOAD, cache, input, input[INPUT]);
+ }
+ }
+ obj.error = function(type, data, evt){
+ if(callbacks && callbacks.length){
+ callbacks.shift()(ERROR, {}, input, input[INPUT]);
+ }
+ }
+ }
+
+ search.push(obj);
+ }else if(type == "pkgmeta"){
+ var cached = getCache(name, "meta");
+
+ if(cached.requires){
+ if(callbacks && callbacks.length){
+ callbacks.shift()(LOAD, cached, input, input[INPUT]);
+ return;
+ }
+ }
+
+ dojo.debug("Finding package meta for: " + name);
+
+ var obj = {};
+
+ obj.url = name + "/meta";
+ obj.load = function(type, data, evt){
+ dojo.debug("_buildCache() loaded for: " + name);
+
+ var methods = data.methods;
+ if(methods){
+ for(var method in methods){
+ if (method == "is") {
+ continue;
+ }
+ for(var pId in methods[method]){
+ getCache(name, META, METHODS, method, pId, META).summary = methods[method][pId];
+ }
+ }
+ }
+
+ var requires = data.requires;
+ var cache = getCache(name, META);
+ if(requires){
+ cache.requires = requires;
+ }
+ if(callbacks && callbacks.length){
+ callbacks.shift()(LOAD, cache, input, input[INPUT]);
+ }
+ }
+ obj.error = function(type, data, evt){
+ if(callbacks && callbacks.length){
+ callbacks.shift()(ERROR, {}, input, input[INPUT]);
+ }
+ }
+ search.push(obj);
+ }
+
+ for(var i = 0, obj; obj = search[i]; i++){
+ var load = obj.load;
+ var error = obj.error;
+ delete obj.load;
+ delete obj.error;
+ var mimetype = obj.mimetype;
+ if(!mimetype){
+ mimetype = "text/json"
+ }
+ if(obj.url){
+ dojo.io.bind({
+ url: new dojo.uri.Uri(docs._url, obj.url),
+ input: input,
+ mimetype: mimetype,
+ error: error,
+ load: load
+ });
+ }else{
+ docs._rpc.callRemote("search", obj).addCallbacks(load, error);
+ }
+ }
+ },
+ selectFunction: function(/*String*/ name, /*String?*/ id){
+ // summary: The combined information
+ },
+ savePackage: function(/*Object*/ callbackObject, /*String*/ callback, /*Object*/ parameters){
+ dojo.event.kwConnect({
+ srcObj: dojo.docs,
+ srcFunc: "_savedPkgRpc",
+ targetObj: callbackObject,
+ targetFunc: callback,
+ once: true
+ });
+
+ var props = {};
+ var cache = dojo.docs._getCache(parameters.pkg, "meta");
+
+ var i = 1;
+
+ if(!cache.path){
+ var path = "id";
+ props[["pname", i].join("")] = "DocPkgForm/require";
+ props[["pvalue", i++].join("")] = parameters.pkg;
+ }else{
+ var path = cache.path;
+ }
+
+ props.form = "//DocPkgForm";
+ props.path = ["/WikiHome/DojoDotDoc/", path].join("");
+
+ if(parameters.description){
+ props[["pname", i].join("")] = "main/text";
+ props[["pvalue", i++].join("")] = parameters.description;
+ }
+
+ dojo.docs._rpc.callRemote("saveForm", props).addCallbacks(dojo.docs._pkgRpc, dojo.docs._pkgRpc);
+ },
+ _pkgRpc: function(data){
+ if(data.name){
+ dojo.docs._getCache(data["DocPkgForm/require"], "meta").path = data.name;
+ dojo.docs._savedPkgRpc("load");
+ }else{
+ dojo.docs._savedPkgRpc("error");
+ }
+ },
+ _savedPkgRpc: function(type){
+ },
+ functionPackages: function(/*mixed*/ selectKey, /*String*/ name, /*Function*/ callback, /*Object*/ input){
+ // summary: Gets the package associated with a function and stores it in the .pkg value of input
+ dojo.debug("functionPackages() name: " + name);
+
+ if(!input){
+ input = {};
+ }
+ if(!input.callbacks){
+ input.callbacks = [];
+ }
+
+ input.type = "function_names";
+ input.name = name;
+ input.callbacks.unshift(callback);
+ input.callbacks.unshift(dojo.docs._functionPackages);
+ dojo.docs._buildCache(input);
+ },
+ _functionPackages: function(/*String*/ type, /*Array*/ data, /*Object*/ evt){
+ dojo.debug("_functionPackages() name: " + evt.name);
+ evt.pkg = '';
+
+ var results = [];
+ var data = dojo.docs._cache['function_names'];
+ for(var key in data){
+ if(dojo.lang.inArray(data[key], evt.name)){
+ dojo.debug("_functionPackages() package: " + key);
+ results.push(key);
+ }
+ }
+
+ if(evt.callbacks && evt.callbacks.length){
+ evt.callbacks.shift()(type, results, evt, evt.input);
+ }
+ },
+ setUserName: function(/*String*/ name){
+ dojo.docs._userName = name;
+ if(name && dojo.docs._password){
+ dojo.docs._logIn();
+ }
+ },
+ setPassword: function(/*String*/ password){
+ dojo.docs._password = password;
+ if(password && dojo.docs._userName){
+ dojo.docs._logIn();
+ }
+ },
+ _logIn: function(){
+ dojo.io.bind({
+ url: dojo.docs._rpc.serviceUrl.toString(),
+ method: "post",
+ mimetype: "text/json",
+ content: {
+ username: dojo.docs._userName,
+ password: dojo.docs._password
+ },
+ load: function(type, data){
+ if(data.error){
+ dojo.docs.logInSuccess();
+ }else{
+ dojo.docs.logInFailure();
+ }
+ },
+ error: function(){
+ dojo.docs.logInFailure();
+ }
+ });
+ },
+ logInSuccess: function(){},
+ logInFailure: function(){},
+ _set: function(/*Object*/ base, /*String...*/ keys, /*String*/ value){
+ var args = [];
+ for(var i = 0, arg; arg = arguments[i]; i++){
+ args.push(arg);
+ }
+
+ if(args.length < 3) return;
+ base = args.shift();
+ value = args.pop();
+ var key = args.pop();
+ for(var i = 0, arg; arg = args[i]; i++){
+ if(typeof base[arg] != "object"){
+ base[arg] = {};
+ }
+ base = base[arg];
+ }
+ base[key] = value;
+ },
+ _getCache: function(/*String...*/ keys){
+ var obj = dojo.docs._cache;
+ for(var i = 0; i < arguments.length; i++){
+ var arg = arguments[i];
+ if(!obj[arg]){
+ obj[arg] = {};
+ }
+ obj = obj[arg];
+ }
+ return obj;
+ }
+});
+
+dojo.event.topic.subscribe("/docs/search", dojo.docs, "_onDocSearch");
+dojo.event.topic.subscribe("/docs/function/select", dojo.docs, "_onDocSelectFunction");
+dojo.event.topic.subscribe("/docs/package/select", dojo.docs, "_onDocSelectPackage");
+
+dojo.event.topic.registerPublisher("/docs/function/results", dojo.docs, "_printFunctionResults");
+dojo.event.topic.registerPublisher("/docs/function/detail", dojo.docs, "_printFunctionDetail");
+dojo.event.topic.registerPublisher("/docs/package/detail", dojo.docs, "_printPkgResult");
\ No newline at end of file
Index: openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/dom.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/Attic/dom.js,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/ajaxhelper/www/resources/dojo-ajax/src/dom.js 6 Nov 2006 14:37:20 -0000 1.1
@@ -0,0 +1,522 @@
+/*
+ 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.removeChildren = function(/* Element */node){
+ // summary
+ // removes all children from node and returns the count of children removed.
+ var count = node.childNodes.length;
+ while(node.hasChildNodes()){ node.removeChild(node.firstChild); }
+ return count; // number
+}
+
+dojo.dom.replaceChildren = function(/* Element */node, /* Node */newChild){
+ // summary
+ // Removes all children of node and appends newChild
+ // FIXME: what if newChild is an array-like object?
+ dojo.dom.removeChildren(node);
+ node.appendChild(newChild);
+}
+
+dojo.dom.removeNode = function(/* Node */node){
+ // summary
+ // if node has a parent, removes node from parent and returns a reference to the removed child.
+ 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; i1) {
+ 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 node && node.parentNode && dojo.dom.isNode(node.parentNode); // boolean
+}
+
+/**
+ * Examples:
+ *
+ * myFooNode =
+ * 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 0){
+ for(var i = 0;i < dojo.flash._loadedListeners.length; i++){
+ dojo.flash._loadedListeners[i].call(null);
+ }
+ }
+ },
+
+ /**
+ A callback to know if Flash is currently being installed or
+ having its version revved. To be notified if Flash is installing, connect
+ your callback to this method using the following:
+
+ dojo.event.connect(dojo.flash, "installing", myInstance, "myCallback");
+ */
+ installing: function(){
+ //dojo.debug("installing");
+ if(dojo.flash._installingListeners.length > 0){
+ for(var i = 0; i < dojo.flash._installingListeners.length; i++){
+ dojo.flash._installingListeners[i].call(null);
+ }
+ }
+ },
+
+ /** Initializes dojo.flash. */
+ _initialize: function(){
+ //dojo.debug("dojo.flash._initialize");
+ // see if we need to rev or install Flash on this platform
+ var installer = new dojo.flash.Install();
+ dojo.flash.installer = installer;
+
+ if(installer.needed() == true){
+ installer.install();
+ }else{
+ //dojo.debug("Writing object out");
+ // write the flash object into the page
+ dojo.flash.obj = new dojo.flash.Embed(this._visible);
+ dojo.flash.obj.write(dojo.flash.info.commVersion);
+
+ // initialize the way we do Flash/JavaScript communication
+ dojo.flash.comm = new dojo.flash.Communicator();
+ }
+ }
+};
+
+
+/**
+ A class that helps us determine whether Flash is available,
+ it's major and minor versions, and what Flash version features should
+ be used for Flash/JavaScript communication. Parts of this code
+ are adapted from the automatic Flash plugin detection code autogenerated
+ by the Macromedia Flash 8 authoring environment.
+
+ An instance of this class can be accessed on dojo.flash.info after
+ the page is finished loading.
+
+ This constructor must be called before the page is finished loading.
+*/
+dojo.flash.Info = function(){
+ // Visual basic helper required to detect Flash Player ActiveX control
+ // version information on Internet Explorer
+ if(dojo.render.html.ie){
+ document.writeln('');
+
+ // hook for Internet Explorer to receive FSCommands from Flash
+ if(dojo.render.html.ie){
+ document.writeln('