public/tt-rss
1
0
Fork 0
mirror of https://git.tt-rss.org/git/tt-rss.git synced 2025-12-19 23:31:30 +00:00
Code Issues Releases Wiki Activity

dojo: remove uncompressed files

Browse Source
This commit is contained in:
Andrew Dolgov
2012-08-14 19:04:32 +04:00
parent 973c4a649f
commit 0181c01109
724 changed files with 0 additions and 137570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

220
lib/dojo/_base/Color.js.uncompressed.js
View File

@@ -1,220 +0,0 @@
define("dojo/_base/Color", ["./kernel", "./lang", "./array", "./config"], function(dojo, lang, ArrayUtil, config){
var Color = dojo.Color = function(/*Array|String|Object*/ color){
// summary:
// Takes a named string, hex string, array of rgb or rgba values,
// an object with r, g, b, and a properties, or another `dojo.Color` object
// and creates a new Color instance to work from.
//
// example:
// Work with a Color instance:
// | var c = new dojo.Color();
// | c.setColor([0,0,0]); // black
// | var hex = c.toHex(); // #000000
//
// example:
// Work with a node's color:
// | var color = dojo.style("someNode", "backgroundColor");
// | var n = new dojo.Color(color);
// | // adjust the color some
// | n.r *= .5;
// | console.log(n.toString()); // rgb(128, 255, 255);
if(color){ this.setColor(color); }
};
/*=====
lang.mixin(dojo.Color,{
named:{
// summary: Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values.
}
});
=====*/
// FIXME:
// there's got to be a more space-efficient way to encode or discover
// these!! Use hex?
Color.named = {
"black": [0,0,0],
"silver": [192,192,192],
"gray": [128,128,128],
"white": [255,255,255],
"maroon": [128,0,0],
"red": [255,0,0],
"purple": [128,0,128],
"fuchsia":[255,0,255],
"green": [0,128,0],
"lime": [0,255,0],
"olive": [128,128,0],
"yellow": [255,255,0],
"navy": [0,0,128],
"blue": [0,0,255],
"teal": [0,128,128],
"aqua": [0,255,255],
"transparent": config.transparentColor || [0,0,0,0]
};
lang.extend(Color, {
r: 255, g: 255, b: 255, a: 1,
_set: function(r, g, b, a){
var t = this; t.r = r; t.g = g; t.b = b; t.a = a;
},
setColor: function(/*Array|String|Object*/ color){
// summary:
// Takes a named string, hex string, array of rgb or rgba values,
// an object with r, g, b, and a properties, or another `dojo.Color` object
// and sets this color instance to that value.
//
// example:
// | var c = new dojo.Color(); // no color
// | c.setColor("#ededed"); // greyish
if(lang.isString(color)){
Color.fromString(color, this);
}else if(lang.isArray(color)){
Color.fromArray(color, this);
}else{
this._set(color.r, color.g, color.b, color.a);
if(!(color instanceof Color)){ this.sanitize(); }
}
return this; // dojo.Color
},
sanitize: function(){
// summary:
// Ensures the object has correct attributes
// description:
// the default implementation does nothing, include dojo.colors to
// augment it with real checks
return this; // dojo.Color
},
toRgb: function(){
// summary:
// Returns 3 component array of rgb values
// example:
// | var c = new dojo.Color("#000000");
// | console.log(c.toRgb()); // [0,0,0]
var t = this;
return [t.r, t.g, t.b]; // Array
},
toRgba: function(){
// summary:
// Returns a 4 component array of rgba values from the color
// represented by this object.
var t = this;
return [t.r, t.g, t.b, t.a]; // Array
},
toHex: function(){
// summary:
// Returns a CSS color string in hexadecimal representation
// example:
// | console.log(new dojo.Color([0,0,0]).toHex()); // #000000
var arr = ArrayUtil.map(["r", "g", "b"], function(x){
var s = this[x].toString(16);
return s.length < 2 ? "0" + s : s;
}, this);
return "#" + arr.join(""); // String
},
toCss: function(/*Boolean?*/ includeAlpha){
// summary:
// Returns a css color string in rgb(a) representation
// example:
// | var c = new dojo.Color("#FFF").toCss();
// | console.log(c); // rgb('255','255','255')
var t = this, rgb = t.r + ", " + t.g + ", " + t.b;
return (includeAlpha ? "rgba(" + rgb + ", " + t.a : "rgb(" + rgb) + ")"; // String
},
toString: function(){
// summary:
// Returns a visual representation of the color
return this.toCss(true); // String
}
});
Color.blendColors = dojo.blendColors = function(
/*dojo.Color*/ start,
/*dojo.Color*/ end,
/*Number*/ weight,
/*dojo.Color?*/ obj
){
// summary:
// Blend colors end and start with weight from 0 to 1, 0.5 being a 50/50 blend,
// can reuse a previously allocated dojo.Color object for the result
var t = obj || new Color();
ArrayUtil.forEach(["r", "g", "b", "a"], function(x){
t[x] = start[x] + (end[x] - start[x]) * weight;
if(x != "a"){ t[x] = Math.round(t[x]); }
});
return t.sanitize(); // dojo.Color
};
Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){
// summary:
// Returns a `dojo.Color` instance from a string of the form
// "rgb(...)" or "rgba(...)". Optionally accepts a `dojo.Color`
// object to update with the parsed value and return instead of
// creating a new object.
// returns:
// A dojo.Color object. If obj is passed, it will be the return value.
var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);
return m && Color.fromArray(m[1].split(/\s*,\s*/), obj); // dojo.Color
};
Color.fromHex = dojo.colorFromHex = function(/*String*/ color, /*dojo.Color?*/ obj){
// summary:
// Converts a hex string with a '#' prefix to a color object.
// Supports 12-bit #rgb shorthand. Optionally accepts a
// `dojo.Color` object to update with the parsed value.
//
// returns:
// A dojo.Color object. If obj is passed, it will be the return value.
//
// example:
// | var thing = dojo.colorFromHex("#ededed"); // grey, longhand
//
// example:
// | var thing = dojo.colorFromHex("#000"); // black, shorthand
var t = obj || new Color(),
bits = (color.length == 4) ? 4 : 8,
mask = (1 << bits) - 1;
color = Number("0x" + color.substr(1));
if(isNaN(color)){
return null; // dojo.Color
}
ArrayUtil.forEach(["b", "g", "r"], function(x){
var c = color & mask;
color >>= bits;
t[x] = bits == 4 ? 17 * c : c;
});
t.a = 1;
return t; // dojo.Color
};
Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*dojo.Color?*/ obj){
// summary:
// Builds a `dojo.Color` from a 3 or 4 element array, mapping each
// element in sequence to the rgb(a) values of the color.
// example:
// | var myColor = dojo.colorFromArray([237,237,237,0.5]); // grey, 50% alpha
// returns:
// A dojo.Color object. If obj is passed, it will be the return value.
var t = obj || new Color();
t._set(Number(a[0]), Number(a[1]), Number(a[2]), Number(a[3]));
if(isNaN(t.a)){ t.a = 1; }
return t.sanitize(); // dojo.Color
};
Color.fromString = dojo.colorFromString = function(/*String*/ str, /*dojo.Color?*/ obj){
// summary:
// Parses `str` for a color value. Accepts hex, rgb, and rgba
// style color values.
// description:
// Acceptable input values for str may include arrays of any form
// accepted by dojo.colorFromArray, hex strings such as "#aaaaaa", or
// rgb or rgba strings such as "rgb(133, 200, 16)" or "rgba(10, 10,
// 10, 50)"
// returns:
// A dojo.Color object. If obj is passed, it will be the return value.
var a = Color.named[str];
return a && Color.fromArray(a, obj) || Color.fromRgb(str, obj) || Color.fromHex(str, obj); // dojo.Color
};
return Color;
});

366
lib/dojo/_base/Deferred.js.uncompressed.js
View File

@@ -1,366 +0,0 @@
define("dojo/_base/Deferred", ["./kernel", "./lang"], function(dojo, lang){
// module:
// dojo/_base/Deferred
// summary:
// This module defines dojo.Deferred.
var mutator = function(){};
var freeze = Object.freeze || function(){};
// A deferred provides an API for creating and resolving a promise.
dojo.Deferred = function(/*Function?*/ canceller){
// summary:
// Deferreds provide a generic means for encapsulating an asynchronous
// operation and notifying users of the completion and result of the operation.
// description:
// The dojo.Deferred API is based on the concept of promises that provide a
// generic interface into the eventual completion of an asynchronous action.
// The motivation for promises fundamentally is about creating a
// separation of concerns that allows one to achieve the same type of
// call patterns and logical data flow in asynchronous code as can be
// achieved in synchronous code. Promises allows one
// to be able to call a function purely with arguments needed for
// execution, without conflating the call with concerns of whether it is
// sync or async. One shouldn't need to alter a call's arguments if the
// implementation switches from sync to async (or vice versa). By having
// async functions return promises, the concerns of making the call are
// separated from the concerns of asynchronous interaction (which are
// handled by the promise).
//
// The dojo.Deferred is a type of promise that provides methods for fulfilling the
// promise with a successful result or an error. The most important method for
// working with Dojo's promises is the then() method, which follows the
// CommonJS proposed promise API. An example of using a Dojo promise:
//
// | var resultingPromise = someAsyncOperation.then(function(result){
// | ... handle result ...
// | },
// | function(error){
// | ... handle error ...
// | });
//
// The .then() call returns a new promise that represents the result of the
// execution of the callback. The callbacks will never affect the original promises value.
//
// The dojo.Deferred instances also provide the following functions for backwards compatibility:
//
// * addCallback(handler)
// * addErrback(handler)
// * callback(result)
// * errback(result)
//
// Callbacks are allowed to return promises 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.
// example:
// | var deferred = new dojo.Deferred();
// | setTimeout(function(){ deferred.callback({success: true}); }, 1000);
// | return deferred;
// example:
// Deferred objects are often used when making code asynchronous. It
// may be easiest to write functions in a synchronous manner and then
// split code using a deferred to trigger a response to a long-lived
// operation. For example, instead of register a callback function to
// denote when a rendering operation completes, the function can
// simply return a deferred:
//
// | // callback style:
// | function renderLotsOfData(data, callback){
// | var success = false
// | try{
// | for(var x in data){
// | renderDataitem(data[x]);
// | }
// | success = true;
// | }catch(e){ }
// | if(callback){
// | callback(success);
// | }
// | }
//
// | // using callback style
// | renderLotsOfData(someDataObj, function(success){
// | // handles success or failure
// | if(!success){
// | promptUserToRecover();
// | }
// | });
// | // NOTE: no way to add another callback here!!
// example:
// Using a Deferred doesn't simplify the sending code any, but it
// provides a standard interface for callers and senders alike,
// providing both with a simple way to service multiple callbacks for
// an operation and freeing both sides from worrying about details
// such as "did this get called already?". With Deferreds, new
// callbacks can be added at any time.
//
// | // Deferred style:
// | function renderLotsOfData(data){
// | var d = new dojo.Deferred();
// | try{
// | for(var x in data){
// | renderDataitem(data[x]);
// | }
// | d.callback(true);
// | }catch(e){
// | d.errback(new Error("rendering failed"));
// | }
// | return d;
// | }
//
// | // using Deferred style
// | renderLotsOfData(someDataObj).then(null, function(){
// | promptUserToRecover();
// | });
// | // NOTE: addErrback and addCallback both return the Deferred
// | // again, so we could chain adding callbacks or save the
// | // deferred for later should we need to be notified again.
// example:
// In this example, renderLotsOfData is synchronous and so both
// versions are pretty artificial. Putting the data display on a
// timeout helps show why Deferreds rock:
//
// | // Deferred style and async func
// | function renderLotsOfData(data){
// | var d = new dojo.Deferred();
// | setTimeout(function(){
// | try{
// | for(var x in data){
// | renderDataitem(data[x]);
// | }
// | d.callback(true);
// | }catch(e){
// | d.errback(new Error("rendering failed"));
// | }
// | }, 100);
// | return d;
// | }
//
// | // using Deferred style
// | renderLotsOfData(someDataObj).then(null, function(){
// | promptUserToRecover();
// | });
//
// Note that the caller doesn't have to change his code at all to
// handle the asynchronous case.
var result, finished, isError, head, nextListener;
var promise = (this.promise = {});
function complete(value){
if(finished){
throw new Error("This deferred has already been resolved");
}
result = value;
finished = true;
notify();
}
function notify(){
var mutated;
while(!mutated && nextListener){
var listener = nextListener;
nextListener = nextListener.next;
if((mutated = (listener.progress == mutator))){ // assignment and check
finished = false;
}
var func = (isError ? listener.error : listener.resolved);
if(func){
try{
var newResult = func(result);
if (newResult && typeof newResult.then === "function"){
newResult.then(lang.hitch(listener.deferred, "resolve"), lang.hitch(listener.deferred, "reject"), lang.hitch(listener.deferred, "progress"));
continue;
}
var unchanged = mutated && newResult === undefined;
if(mutated && !unchanged){
isError = newResult instanceof Error;
}
listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult);
}catch(e){
listener.deferred.reject(e);
}
}else{
if(isError){
listener.deferred.reject(result);
}else{
listener.deferred.resolve(result);
}
}
}
}
// calling resolve will resolve the promise
this.resolve = this.callback = function(value){
// summary:
// Fulfills the Deferred instance successfully with the provide value
this.fired = 0;
this.results = [value, null];
complete(value);
};
// calling error will indicate that the promise failed
this.reject = this.errback = function(error){
// summary:
// Fulfills the Deferred instance as an error with the provided error
isError = true;
this.fired = 1;
complete(error);
this.results = [null, error];
if(!error || error.log !== false){
(dojo.config.deferredOnError || function(x){ console.error(x); })(error);
}
};
// call progress to provide updates on the progress on the completion of the promise
this.progress = function(update){
// summary:
// Send progress events to all listeners
var listener = nextListener;
while(listener){
var progress = listener.progress;
progress && progress(update);
listener = listener.next;
}
};
this.addCallbacks = function(callback, errback){
// summary:
// Adds callback and error callback for this deferred instance.
// callback: Function?
// The callback attached to this deferred object.
// errback: Function?
// The error callback attached to this deferred object.
// returns:
// Returns this deferred object.
this.then(callback, errback, mutator);
return this; // dojo.Deferred
};
// provide the implementation of the promise
promise.then = this.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){
// summary:
// Adds a fulfilledHandler, errorHandler, and progressHandler to be called for
// completion of a promise. The fulfilledHandler is called when the promise
// is fulfilled. The errorHandler is called when a promise fails. The
// progressHandler is called for progress events. All arguments are optional
// and non-function values are ignored. The progressHandler is not only an
// optional argument, but progress events are purely optional. Promise
// providers are not required to ever create progress events.
//
// This function will return a new promise that is fulfilled when the given
// fulfilledHandler or errorHandler callback is finished. This allows promise
// operations to be chained together. The value returned from the callback
// handler is the fulfillment value for the returned promise. If the callback
// throws an error, the returned promise will be moved to failed state.
//
// returns:
// Returns a new promise that represents the result of the
// execution of the callback. The callbacks will never affect the original promises value.
// example:
// An example of using a CommonJS compliant promise:
// | asyncComputeTheAnswerToEverything().
// | then(addTwo).
// | then(printResult, onError);
// | >44
//
var returnDeferred = progressCallback == mutator ? this : new dojo.Deferred(promise.cancel);
var listener = {
resolved: resolvedCallback,
error: errorCallback,
progress: progressCallback,
deferred: returnDeferred
};
if(nextListener){
head = head.next = listener;
}
else{
nextListener = head = listener;
}
if(finished){
notify();
}
return returnDeferred.promise; // Promise
};
var deferred = this;
promise.cancel = this.cancel = function (){
// summary:
// Cancels the asynchronous operation
if(!finished){
var error = canceller && canceller(deferred);
if(!finished){
if (!(error instanceof Error)){
error = new Error(error);
}
error.log = false;
deferred.reject(error);
}
}
};
freeze(promise);
};
lang.extend(dojo.Deferred, {
addCallback: function (/*Function*/ callback){
// summary:
// Adds successful callback for this deferred instance.
// returns:
// Returns this deferred object.
return this.addCallbacks(lang.hitch.apply(dojo, arguments)); // dojo.Deferred
},
addErrback: function (/*Function*/ errback){
// summary:
// Adds error callback for this deferred instance.
// returns:
// Returns this deferred object.
return this.addCallbacks(null, lang.hitch.apply(dojo, arguments)); // dojo.Deferred
},
addBoth: function (/*Function*/ callback){
// summary:
// Add handler as both successful callback and error callback for this deferred instance.
// returns:
// Returns this deferred object.
var enclosed = lang.hitch.apply(dojo, arguments);
return this.addCallbacks(enclosed, enclosed); // dojo.Deferred
},
fired: -1
});
dojo.Deferred.when = dojo.when = function(promiseOrValue, /*Function?*/ callback, /*Function?*/ errback, /*Function?*/ progressHandler){
// summary:
// This provides normalization between normal synchronous values and
// asynchronous promises, so you can interact with them in a common way
// returns:
// Returns a new promise that represents the result of the execution of callback
// when parameter "promiseOrValue" is promise.
// Returns the execution result of callback when parameter "promiseOrValue" is value.
// example:
// | function printFirstAndLast(items){
// | dojo.when(findFirst(items), console.log);
// | dojo.when(findLast(items), console.log);
// | }
// | function findFirst(items){
// | return dojo.when(items, function(items){
// | return items[0];
// | });
// | }
// | function findLast(items){
// | return dojo.when(items, function(items){
// | return items[items.length - 1];
// | });
// | }
// And now all three of his functions can be used sync or async.
// | printFirstAndLast([1,2,3,4]) will work just as well as
// | printFirstAndLast(dojo.xhrGet(...));
if(promiseOrValue && typeof promiseOrValue.then === "function"){
return promiseOrValue.then(callback, errback, progressHandler);
}
return callback ? callback(promiseOrValue) : promiseOrValue; // Promise
};
return dojo.Deferred;
});

100
lib/dojo/_base/NodeList.js.uncompressed.js
View File

@@ -1,100 +0,0 @@
define("dojo/_base/NodeList", ["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){
// module:
// dojo/_base/NodeList
// summary:
// This module defines dojo.NodeList.
var NodeList = query.NodeList;
/*=====
dojo.extend(dojo.NodeList, {
connect: function(methodName, objOrFunc, funcName){
// summary:
// attach event handlers to every item of the NodeList. Uses dojo.connect()
// so event properties are normalized
// methodName: String
// the name of the method to attach to. For DOM events, this should be
// the lower-case name of the event
// objOrFunc: Object|Function|String
// if 2 arguments are passed (methodName, objOrFunc), objOrFunc should
// reference a function or be the name of the function in the global
// namespace to attach. If 3 arguments are provided
// (methodName, objOrFunc, funcName), objOrFunc must be the scope to
// locate the bound function in
// funcName: String?
// optional. A string naming the function in objOrFunc to bind to the
// event. May also be a function reference.
// example:
// add an onclick handler to every button on the page
// | dojo.query("div:nth-child(odd)").connect("onclick", function(e){
// | console.log("clicked!");
// | });
// example:
// attach foo.bar() to every odd div's onmouseover
// | dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
},
coords: function(){
// summary:
// Deprecated: Use position() for border-box x/y/w/h
// or marginBox() for margin-box w/h/l/t.
// Returns the box objects of all elements in a node list as
// an Array (*not* a NodeList). Acts like `dojo.coords`, though assumes
// the node passed is each node in this list.
return dojo.map(this, dojo.coords); // Array
}
});
var NodeList = dojo.NodeList;
=====*/
var nlp = NodeList.prototype;
// don't bind early to dojo.connect since we no longer explicitly depend on it
nlp.connect = NodeList._adaptAsForEach(function(){
return dojo.connect.apply(this, arguments);
});
nlp.coords = NodeList._adaptAsMap(dojo.coords);
NodeList.events = [
// summary:
// list of all DOM events used in NodeList
"blur", "focus", "change", "click", "error", "keydown", "keypress",
"keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove",
"mouseout", "mouseover", "mouseup", "submit"
];
// FIXME: pseudo-doc the above automatically generated on-event functions
// syntactic sugar for DOM events
array.forEach(NodeList.events, function(evt){
var _oe = "on" + evt;
nlp[_oe] = function(a, b){
return this.connect(_oe, a, b);
};
// FIXME: should these events trigger publishes?
/*
return (a ? this.connect(_oe, a, b) :
this.forEach(function(n){
// FIXME:
// listeners get buried by
// addEventListener and can't be dug back
// out to be triggered externally.
// see:
// http://developer.mozilla.org/en/docs/DOM:element
console.log(n, evt, _oe);
// FIXME: need synthetic event support!
var _e = { target: n, faux: true, type: evt };
// dojo._event_listener._synthesizeEvent({}, { target: n, faux: true, type: evt });
try{ n[evt](_e); }catch(e){ console.log(e); }
try{ n[_oe](_e); }catch(e){ console.log(e); }
})
);
*/
}
);
dojo.NodeList = NodeList;
return dojo.NodeList;
});

343
lib/dojo/_base/array.js.uncompressed.js
View File

@@ -1,343 +0,0 @@
define("dojo/_base/array", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
// module:
// dojo/_base/array
// summary:
// This module defines the Javascript v1.6 array extensions.
/*=====
dojo.indexOf = function(arr, value, fromIndex, findLast){
// summary:
// locates the first index of the provided value in the
// passed array. If the value is not found, -1 is returned.
// description:
// This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when
// run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
// 1.6's indexOf skips the holes in the sparse array.
// For details on this method, see:
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
// arr: Array
// value: Object
// fromIndex: Integer?
// findLast: Boolean?
// returns: Number
};
dojo.lastIndexOf = function(arr, value, fromIndex){
// summary:
// locates the last index of the provided value in the passed
// array. If the value is not found, -1 is returned.
// description:
// This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when
// run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
// 1.6's lastIndexOf skips the holes in the sparse array.
// For details on this method, see:
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf
// arr: Array,
// value: Object,
// fromIndex: Integer?
// returns: Number
};
dojo.forEach = function(arr, callback, thisObject){
// summary:
// for every item in arr, callback is invoked. Return values are ignored.
// If you want to break out of the loop, consider using dojo.every() or dojo.some().
// forEach does not allow breaking out of the loop over the items in arr.
// arr:
// the array to iterate over. If a string, operates on individual characters.
// callback:
// a function is invoked with three arguments: item, index, and array
// thisObject:
// may be used to scope the call to callback
// description:
// This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when
// run over sparse arrays, this implementation passes the "holes" in the sparse array to
// the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array.
// For more details, see:
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach
// example:
// | // log out all members of the array:
// | dojo.forEach(
// | [ "thinger", "blah", "howdy", 10 ],
// | function(item){
// | console.log(item);
// | }
// | );
// example:
// | // log out the members and their indexes
// | dojo.forEach(
// | [ "thinger", "blah", "howdy", 10 ],
// | function(item, idx, arr){
// | console.log(item, "at index:", idx);
// | }
// | );
// example:
// | // use a scoped object member as the callback
// |
// | var obj = {
// | prefix: "logged via obj.callback:",
// | callback: function(item){
// | console.log(this.prefix, item);
// | }
// | };
// |
// | // specifying the scope function executes the callback in that scope
// | dojo.forEach(
// | [ "thinger", "blah", "howdy", 10 ],
// | obj.callback,
// | obj
// | );
// |
// | // alternately, we can accomplish the same thing with dojo.hitch()
// | dojo.forEach(
// | [ "thinger", "blah", "howdy", 10 ],
// | dojo.hitch(obj, "callback")
// | );
// arr: Array|String
// callback: Function|String
// thisObject: Object?
};
dojo.every = function(arr, callback, thisObject){
// summary:
// Determines whether or not every item in arr satisfies the
// condition implemented by callback.
// arr: Array|String
// the array to iterate on. If a string, operates on individual characters.
// callback: Function|String
// a function is invoked with three arguments: item, index,
// and array and returns true if the condition is met.
// thisObject: Object?
// may be used to scope the call to callback
// returns: Boolean
// description:
// This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when
// run over sparse arrays, this implementation passes the "holes" in the sparse array to
// the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array.
// For more details, see:
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
// example:
// | // returns false
// | dojo.every([1, 2, 3, 4], function(item){ return item>1; });
// example:
// | // returns true
// | dojo.every([1, 2, 3, 4], function(item){ return item>0; });
};
dojo.some = function(arr, callback, thisObject){
// summary:
// Determines whether or not any item in arr satisfies the
// condition implemented by callback.
// arr: Array|String
// the array to iterate over. If a string, operates on individual characters.
// callback: Function|String
// a function is invoked with three arguments: item, index,
// and array and returns true if the condition is met.
// thisObject: Object?
// may be used to scope the call to callback
// returns: Boolean
// description:
// This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when
// run over sparse arrays, this implementation passes the "holes" in the sparse array to
// the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array.
// For more details, see:
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
// example:
// | // is true
// | dojo.some([1, 2, 3, 4], function(item){ return item>1; });
// example:
// | // is false
// | dojo.some([1, 2, 3, 4], function(item){ return item<1; });
};
dojo.map = function(arr, callback, thisObject){
// summary:
// applies callback to each element of arr and returns
// an Array with the results
// arr: Array|String
// the array to iterate on. If a string, operates on
// individual characters.
// callback: Function|String
// a function is invoked with three arguments, (item, index,
// array), and returns a value
// thisObject: Object?
// may be used to scope the call to callback
// returns: Array
// description:
// This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
// run over sparse arrays, this implementation passes the "holes" in the sparse array to
// the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
// For more details, see:
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
// example:
// | // returns [2, 3, 4, 5]
// | dojo.map([1, 2, 3, 4], function(item){ return item+1 });
};
dojo.filter = function(arr, callback, thisObject){
// summary:
// Returns a new Array with those items from arr that match the
// condition implemented by callback.
// arr: Array
// the array to iterate over.
// callback: Function|String
// a function that is invoked with three arguments (item,
// index, array). The return of this function is expected to
// be a boolean which determines whether the passed-in item
// will be included in the returned array.
// thisObject: Object?
// may be used to scope the call to callback
// returns: Array
// description:
// This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when
// run over sparse arrays, this implementation passes the "holes" in the sparse array to
// the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array.
// For more details, see:
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
// example:
// | // returns [2, 3, 4]
// | dojo.filter([1, 2, 3, 4], function(item){ return item>1; });
};
=====*/
// our old simple function builder stuff
var cache = {}, u, array; // the export object
function clearCache(){
cache = {};
}
function buildFn(fn){
return cache[fn] = new Function("item", "index", "array", fn); // Function
}
// magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
// every & some
function everyOrSome(some){
var every = !some;
return function(a, fn, o){
var i = 0, l = a && a.length || 0, result;
if(l && typeof a == "string") a = a.split("");
if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
if(o){
for(; i < l; ++i){
result = !fn.call(o, a[i], i, a);
if(some ^ result){
return !result;
}
}
}else{
for(; i < l; ++i){
result = !fn(a[i], i, a);
if(some ^ result){
return !result;
}
}
}
return every; // Boolean
}
}
// var every = everyOrSome(false), some = everyOrSome(true);
// indexOf, lastIndexOf
function index(up){
var delta = 1, lOver = 0, uOver = 0;
if(!up){
delta = lOver = uOver = -1;
}
return function(a, x, from, last){
if(last && delta > 0){
// TODO: why do we use a non-standard signature? why do we need "last"?
return array.lastIndexOf(a, x, from);
}
var l = a && a.length || 0, end = up ? l + uOver : lOver, i;
if(from === u){
i = up ? lOver : l + uOver;
}else{
if(from < 0){
i = l + from;
if(i < 0){
i = lOver;
}
}else{
i = from >= l ? l + uOver : from;
}
}
if(l && typeof a == "string") a = a.split("");
for(; i != end; i += delta){
if(a[i] == x){
return i; // Number
}
}
return -1; // Number
}
}
// var indexOf = index(true), lastIndexOf = index(false);
function forEach(a, fn, o){
var i = 0, l = a && a.length || 0;
if(l && typeof a == "string") a = a.split("");
if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
if(o){
for(; i < l; ++i){
fn.call(o, a[i], i, a);
}
}else{
for(; i < l; ++i){
fn(a[i], i, a);
}
}
}
function map(a, fn, o, Ctr){
// TODO: why do we have a non-standard signature here? do we need "Ctr"?
var i = 0, l = a && a.length || 0, out = new (Ctr || Array)(l);
if(l && typeof a == "string") a = a.split("");
if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
if(o){
for(; i < l; ++i){
out[i] = fn.call(o, a[i], i, a);
}
}else{
for(; i < l; ++i){
out[i] = fn(a[i], i, a);
}
}
return out; // Array
}
function filter(a, fn, o){
// TODO: do we need "Ctr" here like in map()?
var i = 0, l = a && a.length || 0, out = [], value;
if(l && typeof a == "string") a = a.split("");
if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
if(o){
for(; i < l; ++i){
value = a[i];
if(fn.call(o, value, i, a)){
out.push(value);
}
}
}else{
for(; i < l; ++i){
value = a[i];
if(fn(value, i, a)){
out.push(value);
}
}
}
return out; // Array
}
array = {
every: everyOrSome(false),
some: everyOrSome(true),
indexOf: index(true),
lastIndexOf: index(false),
forEach: forEach,
map: map,
filter: filter,
clearCache: clearCache
};
1 && lang.mixin(dojo, array);
/*===== return dojo.array; =====*/
return array;
});

21
lib/dojo/_base/browser.js.uncompressed.js
View File

@@ -1,21 +0,0 @@
if(require.has){
require.has.add("config-selectorEngine", "acme");
}
define("dojo/_base/browser", [
"../ready",
"./kernel",
"./connect", // until we decide if connect is going back into non-browser environments
"./unload",
"./window",
"./event",
"./html",
"./NodeList",
"../query",
"./xhr",
"./fx"], function(dojo) {
// module:
// dojo/_base/browser
// summary:
// This module causes the browser-only base modules to be loaded.
return dojo;
});

174
lib/dojo/_base/config.js.uncompressed.js
View File

@@ -1,174 +0,0 @@
define("dojo/_base/config", ["../has", "require"], function(has, require){
// module:
// dojo/_base/config
// summary:
// This module defines the user configuration during bootstrap.
// description:
// By defining user configuration as a module value, an entire configuration can be specified in a build,
// thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
// Also, when multiple instances of dojo exist in a single application, each will necessarily be located
// at an unique absolute module identifier as given by the package configuration. Implementing configuration
// as a module allows for specifying unique, per-instance configurations.
// example:
// Create a second instance of dojo with a different, instance-uniqe configuration (assume the loader and
// dojo.js are already loaded).
// | // specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
// | require({
// | packages:[{
// | name:"myDojo",
// | location:".", //assume baseUrl points to dojo.js
// | }]
// | });
// |
// | // specify a configuration for the myDojo instance
// | define("myDojo/config", {
// | // normal configuration variables go here, e.g.,
// | locale:"fr-ca"
// | });
// |
// | // load and use the new instance of dojo
// | require(["myDojo"], function(dojo) {
// | // dojo is the new instance of dojo
// | // use as required
// | });
var result = {};
if(1){
// must be the dojo loader; take a shallow copy of require.rawConfig
var src = require.rawConfig, p;
for(p in src){
result[p] = src[p];
}
}else{
var adviseHas = function(featureSet, prefix, booting){
for(p in featureSet){
p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
}
};
result = 1 ?
// must be a built version of the dojo loader; all config stuffed in require.rawConfig
require.rawConfig :
// a foreign loader
this.dojoConfig || this.djConfig || {};
adviseHas(result, "config", 1);
adviseHas(result.has, "", 1);
}
return result;
/*=====
// note:
// 'dojoConfig' does not exist under 'dojo.*' so that it can be set before the
// 'dojo' variable exists.
// note:
// Setting any of these variables *after* the library has loaded does
// nothing at all.
// FIXME: can we document these on dojo.config object and explain they must be set via djConfig/dojoConfig global prior to loading dojo.js
dojoConfig = {
// summary:
// Application code can set the global 'dojoConfig' prior to loading
// the library to control certain global settings for how dojo works.
//
// isDebug: Boolean
// Defaults to `false`. If set to `true`, ensures that Dojo provides
// extended debugging feedback via Firebug. If Firebug is not available
// on your platform, setting `isDebug` to `true` will force Dojo to
// pull in (and display) the version of Firebug Lite which is
// integrated into the Dojo distribution, thereby always providing a
// debugging/logging console when `isDebug` is enabled. Note that
// Firebug's `console.*` methods are ALWAYS defined by Dojo. If
// `isDebug` is false and you are on a platform without Firebug, these
// methods will be defined as no-ops.
isDebug: false,
// locale: String
// The locale to assume for loading localized resources in this page,
// specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
// Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
// See the documentation for `dojo.i18n` and `dojo.requireLocalization`
// for details on loading localized resources. If no locale is specified,
// Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
// or `navigator.language` properties.
locale: undefined,
// extraLocale: Array
// No default value. Specifies additional locales whose
// resources should also be loaded alongside the default locale when
// calls to `dojo.requireLocalization()` are processed.
extraLocale: undefined,
// baseUrl: String
// The directory in which `dojo.js` is located. Under normal
// conditions, Dojo auto-detects the correct location from which it
// was loaded. You may need to manually configure `baseUrl` in cases
// where you have renamed `dojo.js` or in which `<base>` tags confuse
// some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
// either the value of `djConfig.baseUrl` if one is provided or the
// auto-detected root if not. Other modules are located relative to
// this path. The path should end in a slash.
baseUrl: undefined,
// modulePaths: Object
// A map of module names to paths relative to `dojo.baseUrl`. The
// key/value pairs correspond directly to the arguments which
// `dojo.registerModulePath` accepts. Specifiying
// `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
// of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
// modules may be configured via `djConfig.modulePaths`.
modulePaths: {},
// afterOnLoad: Boolean
// Indicates Dojo was added to the page after the page load. In this case
// Dojo will not wait for the page DOMContentLoad/load events and fire
// its dojo.addOnLoad callbacks after making sure all outstanding
// dojo.required modules have loaded. Only works with a built dojo.js,
// it does not work the dojo.js directly from source control.
afterOnLoad: false,
// addOnLoad: Function or Array
// Adds a callback via dojo.addOnLoad. Useful when Dojo is added after
// the page loads and djConfig.afterOnLoad is true. Supports the same
// arguments as dojo.addOnLoad. When using a function reference, use
// `djConfig.addOnLoad = function(){};`. For object with function name use
// `djConfig.addOnLoad = [myObject, "functionName"];` and for object with
// function reference use
// `djConfig.addOnLoad = [myObject, function(){}];`
addOnLoad: null,
// require: Array
// An array of module names to be loaded immediately after dojo.js has been included
// in a page.
require: [],
// defaultDuration: Array
// Default duration, in milliseconds, for wipe and fade animations within dijits.
// Assigned to dijit.defaultDuration.
defaultDuration: 200,
// dojoBlankHtmlUrl: String
// Used by some modules to configure an empty iframe. Used by dojo.io.iframe and
// dojo.back, and dijit popup support in IE where an iframe is needed to make sure native
// controls do not bleed through the popups. Normally this configuration variable
// does not need to be set, except when using cross-domain/CDN Dojo builds.
// Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
// to the path on your domain your copy of blank.html.
dojoBlankHtmlUrl: undefined,
// ioPublish: Boolean?
// Set this to true to enable publishing of topics for the different phases of
// IO operations. Publishing is done via dojo.publish. See dojo.__IoPublish for a list
// of topics that are published.
ioPublish: false,
// useCustomLogger: Anything?
// If set to a value that evaluates to true such as a string or array and
// isDebug is true and Firebug is not available or running, then it bypasses
// the creation of Firebug Lite allowing you to define your own console object.
useCustomLogger: undefined,
// transparentColor: Array
// Array containing the r, g, b components used as transparent color in dojo.Color;
// if undefined, [255,255,255] (white) will be used.
transparentColor: undefined,
// skipIeDomLoaded: Boolean
// For IE only, skip the DOMContentLoaded hack used. Sometimes it can cause an Operation
// Aborted error if the rest of the page triggers script defers before the DOM is ready.
// If this is config value is set to true, then dojo.addOnLoad callbacks will not be
// triggered until the page load event, which is after images and iframes load. If you
// want to trigger the callbacks sooner, you can put a script block in the bottom of
// your HTML that calls dojo._loadInit();. If you are using multiversion support, change
// "dojo." to the appropriate scope name for dojo.
skipIeDomLoaded: false
}
=====*/
});

400
lib/dojo/_base/connect.js.uncompressed.js
View File

@@ -1,400 +0,0 @@
define("dojo/_base/connect", ["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(kernel, on, hub, aspect, eventModule, mouse, has, lang){
// module:
// dojo/_base/connect
// summary:
// This module defines the dojo.connect API.
// This modules also provides keyboard event handling helpers.
// This module exports an extension event for emulating Firefox's keypress handling.
// However, this extension event exists primarily for backwards compatibility and
// is not recommended. WebKit and IE uses an alternate keypress handling (only
// firing for printable characters, to distinguish from keydown events), and most
// consider the WebKit/IE behavior more desirable.
has.add("events-keypress-typed", function(){ // keypresses should only occur a printable character is hit
var testKeyEvent = {charCode: 0};
try{
testKeyEvent = document.createEvent("KeyboardEvent");
(testKeyEvent.initKeyboardEvent || testKeyEvent.initKeyEvent).call(testKeyEvent, "keypress", true, true, null, false, false, false, false, 9, 3);
}catch(e){}
return testKeyEvent.charCode == 0 && !has("opera");
});
function connect_(obj, event, context, method, dontFix){
method = lang.hitch(context, method);
if(!obj || !(obj.addEventListener || obj.attachEvent)){
// it is a not a DOM node and we are using the dojo.connect style of treating a
// method like an event, must go right to aspect
return aspect.after(obj || kernel.global, event, method, true);
}
if(typeof event == "string" && event.substring(0, 2) == "on"){
event = event.substring(2);
}
if(!obj){
obj = kernel.global;
}
if(!dontFix){
switch(event){
// dojo.connect has special handling for these event types
case "keypress":
event = keypress;
break;
case "mouseenter":
event = mouse.enter;
break;
case "mouseleave":
event = mouse.leave;
break;
}
}
return on(obj, event, method, dontFix);
}
var _punctMap = {
106:42,
111:47,
186:59,
187:43,
188:44,
189:45,
190:46,
191:47,
192:96,
219:91,
220:92,
221:93,
222:39,
229:113
};
var evtCopyKey = has("mac") ? "metaKey" : "ctrlKey";
var _synthesizeEvent = function(evt, props){
var faux = lang.mixin({}, evt, props);
setKeyChar(faux);
// FIXME: would prefer to use lang.hitch: lang.hitch(evt, evt.preventDefault);
// but it throws an error when preventDefault is invoked on Safari
// does Event.preventDefault not support "apply" on Safari?
faux.preventDefault = function(){ evt.preventDefault(); };
faux.stopPropagation = function(){ evt.stopPropagation(); };
return faux;
};
function setKeyChar(evt){
evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
evt.charOrCode = evt.keyChar || evt.keyCode;
}
var keypress;
if(has("events-keypress-typed")){
// this emulates Firefox's keypress behavior where every keydown can correspond to a keypress
var _trySetKeyCode = function(e, code){
try{
// squelch errors when keyCode is read-only
// (e.g. if keyCode is ctrl or shift)
return (e.keyCode = code);
}catch(e){
return 0;
}
};
keypress = function(object, listener){
var keydownSignal = on(object, "keydown", function(evt){
// munge key/charCode
var k=evt.keyCode;
// These are Windows Virtual Key Codes
// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
var unprintable = (k!=13 || (has("ie") >= 9 && !has("quirks"))) && k!=32 && (k!=27||!has("ie")) && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229;
// synthesize keypress for most unprintables and CTRL-keys
if(unprintable||evt.ctrlKey){
var c = unprintable ? 0 : k;
if(evt.ctrlKey){
if(k==3 || k==13){
return listener.call(evt.currentTarget, evt); // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
}else if(c>95 && c<106){
c -= 48; // map CTRL-[numpad 0-9] to ASCII
}else if((!evt.shiftKey)&&(c>=65&&c<=90)){
c += 32; // map CTRL-[A-Z] to lowercase
}else{
c = _punctMap[c] || c; // map other problematic CTRL combinations to ASCII
}
}
// simulate a keypress event
var faux = _synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
listener.call(evt.currentTarget, faux);
if(has("ie")){
_trySetKeyCode(evt, faux.keyCode);
}
}
});
var keypressSignal = on(object, "keypress", function(evt){
var c = evt.charCode;
c = c>=32 ? c : 0;
evt = _synthesizeEvent(evt, {charCode: c, faux: true});
return listener.call(this, evt);
});
return {
remove: function(){
keydownSignal.remove();
keypressSignal.remove();
}
};
};
}else{
if(has("opera")){
keypress = function(object, listener){
return on(object, "keypress", function(evt){
var c = evt.which;
if(c==3){
c=99; // Mozilla maps CTRL-BREAK to CTRL-c
}
// can't trap some keys at all, like INSERT and DELETE
// there is no differentiating info between DELETE and ".", or INSERT and "-"
c = c<32 && !evt.shiftKey ? 0 : c;
if(evt.ctrlKey && !evt.shiftKey && c>=65 && c<=90){
// lowercase CTRL-[A-Z] keys
c += 32;
}
return listener.call(this, _synthesizeEvent(evt, { charCode: c }));
});
};
}else{
keypress = function(object, listener){
return on(object, "keypress", function(evt){
setKeyChar(evt);
return listener.call(this, evt);
});
};
}
}
var connect = {
_keypress:keypress,
connect:function(obj, event, context, method, dontFix){
// normalize arguments
var a=arguments, args=[], i=0;
// if a[0] is a String, obj was omitted
args.push(typeof a[0] == "string" ? null : a[i++], a[i++]);
// if the arg-after-next is a String or Function, context was NOT omitted
var a1 = a[i+1];
args.push(typeof a1 == "string" || typeof a1 == "function" ? a[i++] : null, a[i++]);
// absorb any additional arguments
for(var l=a.length; i<l; i++){ args.push(a[i]); }
return connect_.apply(this, args);
},
disconnect:function(handle){
if(handle){
handle.remove();
}
},
subscribe:function(topic, context, method){
return hub.subscribe(topic, lang.hitch(context, method));
},
publish:function(topic, args){
return hub.publish.apply(hub, [topic].concat(args));
},
connectPublisher:function(topic, obj, event){
var pf = function(){ connect.publish(topic, arguments); };
return event ? connect.connect(obj, event, pf) : connect.connect(obj, pf); //Handle
},
isCopyKey: function(e){
return e[evtCopyKey]; // Boolean
}
};
connect.unsubscribe = connect.disconnect;
1 && lang.mixin(kernel, connect);
return connect;
/*=====
dojo.connect = function(obj, event, context, method, dontFix){
// summary:
// `dojo.connect` is the core event handling and delegation method in
// Dojo. It allows one function to "listen in" on the execution of
// any other, triggering the second whenever the first is called. Many
// listeners may be attached to a function, and source functions may
// be either regular function calls or DOM events.
//
// description:
// Connects listeners to actions, so that after event fires, a
// listener is called with the same arguments passed to the original
// function.
//
// Since `dojo.connect` allows the source of events to be either a
// "regular" JavaScript function or a DOM event, it provides a uniform
// interface for listening to all the types of events that an
// application is likely to deal with though a single, unified
// interface. DOM programmers may want to think of it as
// "addEventListener for everything and anything".
//
// When setting up a connection, the `event` parameter must be a
// string that is the name of the method/event to be listened for. If
// `obj` is null, `kernel.global` is assumed, meaning that connections
// to global methods are supported but also that you may inadvertently
// connect to a global by passing an incorrect object name or invalid
// reference.
//
// `dojo.connect` generally is forgiving. If you pass the name of a
// function or method that does not yet exist on `obj`, connect will
// not fail, but will instead set up a stub method. Similarly, null
// arguments may simply be omitted such that fewer than 4 arguments
// may be required to set up a connection See the examples for details.
//
// The return value is a handle that is needed to
// remove this connection with `dojo.disconnect`.
//
// obj: Object|null:
// The source object for the event function.
// Defaults to `kernel.global` if null.
// If obj is a DOM node, the connection is delegated
// to the DOM event manager (unless dontFix is true).
//
// event: String:
// String name of the event function in obj.
// I.e. identifies a property `obj[event]`.
//
// context: Object|null
// The object that method will receive as "this".
//
// If context is null and method is a function, then method
// inherits the context of event.
//
// If method is a string then context must be the source
// object object for method (context[method]). If context is null,
// kernel.global is used.
//
// method: String|Function:
// A function reference, or name of a function in context.
// The function identified by method fires after event does.
// method receives the same arguments as the event.
// See context argument comments for information on method's scope.
//
// dontFix: Boolean?
// If obj is a DOM node, set dontFix to true to prevent delegation
// of this connection to the DOM event manager.
//
// example:
// When obj.onchange(), do ui.update():
// | dojo.connect(obj, "onchange", ui, "update");
// | dojo.connect(obj, "onchange", ui, ui.update); // same
//
// example:
// Using return value for disconnect:
// | var link = dojo.connect(obj, "onchange", ui, "update");
// | ...
// | dojo.disconnect(link);
//
// example:
// When onglobalevent executes, watcher.handler is invoked:
// | dojo.connect(null, "onglobalevent", watcher, "handler");
//
// example:
// When ob.onCustomEvent executes, customEventHandler is invoked:
// | dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
// | dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
//
// example:
// When ob.onCustomEvent executes, customEventHandler is invoked
// with the same scope (this):
// | dojo.connect(ob, "onCustomEvent", null, customEventHandler);
// | dojo.connect(ob, "onCustomEvent", customEventHandler); // same
//
// example:
// When globalEvent executes, globalHandler is invoked
// with the same scope (this):
// | dojo.connect(null, "globalEvent", null, globalHandler);
// | dojo.connect("globalEvent", globalHandler); // same
}
=====*/
/*=====
dojo.disconnect = function(handle){
// summary:
// Remove a link created by dojo.connect.
// description:
// Removes the connection between event and the method referenced by handle.
// handle: Handle:
// the return value of the dojo.connect call that created the connection.
}
=====*/
/*=====
dojo.subscribe = function(topic, context, method){
// summary:
// Attach a listener to a named topic. The listener function is invoked whenever the
// named topic is published (see: dojo.publish).
// Returns a handle which is needed to unsubscribe this listener.
// topic: String:
// The topic to which to subscribe.
// context: Object|null:
// Scope in which method will be invoked, or null for default scope.
// method: String|Function:
// The name of a function in context, or a function reference. This is the function that
// is invoked when topic is published.
// example:
// | dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); });
// | dojo.publish("alerts", [ "read this", "hello world" ]);
}
=====*/
/*=====
dojo.unsubscribe = function(handle){
// summary:
// Remove a topic listener.
// handle: Handle
// The handle returned from a call to subscribe.
// example:
// | var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
// | ...
// | dojo.unsubscribe(alerter);
}
=====*/
/*=====
dojo.publish = function(topic, args){
// summary:
// Invoke all listener method subscribed to topic.
// topic: String:
// The name of the topic to publish.
// args: Array?
// An array of arguments. The arguments will be applied
// to each topic subscriber (as first class parameters, via apply).
// example:
// | dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
// | dojo.publish("alerts", [ "read this", "hello world" ]);
}
=====*/
/*=====
dojo.connectPublisher = function(topic, obj, event){
// summary:
// Ensure that every time obj.event() is called, a message is published
// on the topic. Returns a handle which can be passed to
// dojo.disconnect() to disable subsequent automatic publication on
// the topic.
// topic: String:
// The name of the topic to publish.
// obj: Object|null:
// The source object for the event function. Defaults to kernel.global
// if null.
// event: String:
// The name of the event function in obj.
// I.e. identifies a property obj[event].
// example:
// | dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
}
=====*/
/*=====
dojo.isCopyKey = function(e){
// summary:
// Checks an event for the copy key (meta on Mac, and ctrl anywhere else)
// e: Event
// Event object to examine
}
=====*/
});

1050
lib/dojo/_base/declare.js.uncompressed.js
View File

File diff suppressed because it is too large Load Diff

51
lib/dojo/_base/event.js.uncompressed.js
View File

@@ -1,51 +0,0 @@
define("dojo/_base/event", ["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){
// module:
// dojo/_base/event
// summary:
// This module defines dojo DOM event API.
if(on._fixEvent){
var fixEvent = on._fixEvent;
on._fixEvent = function(evt, se){
// add some additional normalization for back-compat, this isn't in on.js because it is somewhat more expensive
evt = fixEvent(evt, se);
if(evt){
dom.normalizeEvent(evt);
}
return evt;
};
}
dojo.fixEvent = function(/*Event*/ evt, /*DOMNode*/ sender){
// summary:
// normalizes properties on the event object including event
// bubbling methods, keystroke normalization, and x/y positions
// evt: Event
// native event object
// sender: DOMNode
// node to treat as "currentTarget"
if(on._fixEvent){
return on._fixEvent(evt, sender);
}
return evt; // Event
};
dojo.stopEvent = function(/*Event*/ evt){
// summary:
// prevents propagation and clobbers the default action of the
// passed event
// evt: Event
// The event object. If omitted, window.event is used on IE.
if(has("dom-addeventlistener") || (evt && evt.preventDefault)){
evt.preventDefault();
evt.stopPropagation();
}else{
evt = evt || window.event;
evt.cancelBubble = true;
on._preventDefault.call(evt);
}
};
return {
fix: dojo.fixEvent,
stop: dojo.stopEvent
};
});

666
lib/dojo/_base/fx.js.uncompressed.js
View File

@@ -1,666 +0,0 @@
define("dojo/_base/fx", ["./kernel", "./lang", "../Evented", "./Color", "./connect", "./sniff", "../dom", "../dom-style"], function(dojo, lang, Evented, Color, connect, has, dom, style){
// module:
// dojo/_base/fx
// summary:
// This module defines the base dojo.fx implementation.
// notes:
// Animation loosely package based on Dan Pupius' work, contributed under CLA; see
// http://pupius.co.uk/js/Toolkit.Drawing.js
var _mixin = lang.mixin;
dojo._Line = function(/*int*/ start, /*int*/ end){
// summary:
// dojo._Line is the object used to generate values from a start value
// to an end value
// start: int
// Beginning value for range
// end: int
// Ending value for range
this.start = start;
this.end = end;
};
dojo._Line.prototype.getValue = function(/*float*/ n){
// summary: Returns the point on the line
// n: a floating point number greater than 0 and less than 1
return ((this.end - this.start) * n) + this.start; // Decimal
};
dojo.Animation = function(args){
// summary:
// A generic animation class that fires callbacks into its handlers
// object at various states.
// description:
// A generic animation class that fires callbacks into its handlers
// object at various states. Nearly all dojo animation functions
// return an instance of this method, usually without calling the
// .play() method beforehand. Therefore, you will likely need to
// call .play() on instances of `dojo.Animation` when one is
// returned.
// args: Object
// The 'magic argument', mixing all the properties into this
// animation instance.
_mixin(this, args);
if(lang.isArray(this.curve)){
this.curve = new dojo._Line(this.curve[0], this.curve[1]);
}
};
dojo.Animation.prototype = new Evented();
// Alias to drop come 2.0:
dojo._Animation = dojo.Animation;
lang.extend(dojo.Animation, {
// duration: Integer
// The time in milliseonds the animation will take to run
duration: 350,
/*=====
// curve: dojo._Line|Array
// A two element array of start and end values, or a `dojo._Line` instance to be
// used in the Animation.
curve: null,
// easing: Function?
// A Function to adjust the acceleration (or deceleration) of the progress
// across a dojo._Line
easing: null,
=====*/
// repeat: Integer?
// The number of times to loop the animation
repeat: 0,
// rate: Integer?
// the time in milliseconds to wait before advancing to next frame
// (used as a fps timer: 1000/rate = fps)
rate: 20 /* 50 fps */,
/*=====
// delay: Integer?
// The time in milliseconds to wait before starting animation after it
// has been .play()'ed
delay: null,
// beforeBegin: Event?
// Synthetic event fired before a dojo.Animation begins playing (synchronous)
beforeBegin: null,
// onBegin: Event?
// Synthetic event fired as a dojo.Animation begins playing (useful?)
onBegin: null,
// onAnimate: Event?
// Synthetic event fired at each interval of a `dojo.Animation`
onAnimate: null,
// onEnd: Event?
// Synthetic event fired after the final frame of a `dojo.Animation`
onEnd: null,
// onPlay: Event?
// Synthetic event fired any time a `dojo.Animation` is play()'ed
onPlay: null,
// onPause: Event?
// Synthetic event fired when a `dojo.Animation` is paused
onPause: null,
// onStop: Event
// Synthetic event fires when a `dojo.Animation` is stopped
onStop: null,
=====*/
_percent: 0,
_startRepeatCount: 0,
_getStep: function(){
var _p = this._percent,
_e = this.easing
;
return _e ? _e(_p) : _p;
},
_fire: function(/*Event*/ evt, /*Array?*/ args){
// summary:
// Convenience function. Fire event "evt" and pass it the
// arguments specified in "args".
// description:
// Convenience function. Fire event "evt" and pass it the
// arguments specified in "args".
// Fires the callback in the scope of the `dojo.Animation`
// instance.
// evt:
// The event to fire.
// args:
// The arguments to pass to the event.
var a = args||[];
if(this[evt]){
if(dojo.config.debugAtAllCosts){
this[evt].apply(this, a);
}else{
try{
this[evt].apply(this, a);
}catch(e){
// squelch and log because we shouldn't allow exceptions in
// synthetic event handlers to cause the internal timer to run
// amuck, potentially pegging the CPU. I'm not a fan of this
// squelch, but hopefully logging will make it clear what's
// going on
console.error("exception in animation handler for:", evt);
console.error(e);
}
}
}
return this; // dojo.Animation
},
play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
// summary:
// Start the animation.
// delay:
// How many milliseconds to delay before starting.
// gotoStart:
// If true, starts the animation from the beginning; otherwise,
// starts it from its current position.
// returns: dojo.Animation
// The instance to allow chaining.
var _t = this;
if(_t._delayTimer){ _t._clearTimer(); }
if(gotoStart){
_t._stopTimer();
_t._active = _t._paused = false;
_t._percent = 0;
}else if(_t._active && !_t._paused){
return _t;
}
_t._fire("beforeBegin", [_t.node]);
var de = delay || _t.delay,
_p = lang.hitch(_t, "_play", gotoStart);
if(de > 0){
_t._delayTimer = setTimeout(_p, de);
return _t;
}
_p();
return _t; // dojo.Animation
},
_play: function(gotoStart){
var _t = this;
if(_t._delayTimer){ _t._clearTimer(); }
_t._startTime = new Date().valueOf();
if(_t._paused){
_t._startTime -= _t.duration * _t._percent;
}
_t._active = true;
_t._paused = false;
var value = _t.curve.getValue(_t._getStep());
if(!_t._percent){
if(!_t._startRepeatCount){
_t._startRepeatCount = _t.repeat;
}
_t._fire("onBegin", [value]);
}
_t._fire("onPlay", [value]);
_t._cycle();
return _t; // dojo.Animation
},
pause: function(){
// summary: Pauses a running animation.
var _t = this;
if(_t._delayTimer){ _t._clearTimer(); }
_t._stopTimer();
if(!_t._active){ return _t; /*dojo.Animation*/ }
_t._paused = true;
_t._fire("onPause", [_t.curve.getValue(_t._getStep())]);
return _t; // dojo.Animation
},
gotoPercent: function(/*Decimal*/ percent, /*Boolean?*/ andPlay){
// summary:
// Sets the progress of the animation.
// percent:
// A percentage in decimal notation (between and including 0.0 and 1.0).
// andPlay:
// If true, play the animation after setting the progress.
var _t = this;
_t._stopTimer();
_t._active = _t._paused = true;
_t._percent = percent;
if(andPlay){ _t.play(); }
return _t; // dojo.Animation
},
stop: function(/*boolean?*/ gotoEnd){
// summary: Stops a running animation.
// gotoEnd: If true, the animation will end.
var _t = this;
if(_t._delayTimer){ _t._clearTimer(); }
if(!_t._timer){ return _t; /* dojo.Animation */ }
_t._stopTimer();
if(gotoEnd){
_t._percent = 1;
}
_t._fire("onStop", [_t.curve.getValue(_t._getStep())]);
_t._active = _t._paused = false;
return _t; // dojo.Animation
},
status: function(){
// summary:
// Returns a string token representation of the status of
// the animation, one of: "paused", "playing", "stopped"
if(this._active){
return this._paused ? "paused" : "playing"; // String
}
return "stopped"; // String
},
_cycle: function(){
var _t = this;
if(_t._active){
var curr = new Date().valueOf();
var step = (curr - _t._startTime) / (_t.duration);
if(step >= 1){
step = 1;
}
_t._percent = step;
// Perform easing
if(_t.easing){
step = _t.easing(step);
}
_t._fire("onAnimate", [_t.curve.getValue(step)]);
if(_t._percent < 1){
_t._startTimer();
}else{
_t._active = false;
if(_t.repeat > 0){
_t.repeat--;
_t.play(null, true);
}else if(_t.repeat == -1){
_t.play(null, true);
}else{
if(_t._startRepeatCount){
_t.repeat = _t._startRepeatCount;
_t._startRepeatCount = 0;
}
}
_t._percent = 0;
_t._fire("onEnd", [_t.node]);
!_t.repeat && _t._stopTimer();
}
}
return _t; // dojo.Animation
},
_clearTimer: function(){
// summary: Clear the play delay timer
clearTimeout(this._delayTimer);
delete this._delayTimer;
}
});
// the local timer, stubbed into all Animation instances
var ctr = 0,
timer = null,
runner = {
run: function(){}
};
lang.extend(dojo.Animation, {
_startTimer: function(){
if(!this._timer){
this._timer = connect.connect(runner, "run", this, "_cycle");
ctr++;
}
if(!timer){
timer = setInterval(lang.hitch(runner, "run"), this.rate);
}
},
_stopTimer: function(){
if(this._timer){
connect.disconnect(this._timer);
this._timer = null;
ctr--;
}
if(ctr <= 0){
clearInterval(timer);
timer = null;
ctr = 0;
}
}
});
var _makeFadeable =
has("ie") ? function(node){
// only set the zoom if the "tickle" value would be the same as the
// default
var ns = node.style;
// don't set the width to auto if it didn't already cascade that way.
// We don't want to f anyones designs
if(!ns.width.length && style.get(node, "width") == "auto"){
ns.width = "auto";
}
} :
function(){};
dojo._fade = function(/*Object*/ args){
// summary:
// Returns an animation that will fade the node defined by
// args.node from the start to end values passed (args.start
// args.end) (end is mandatory, start is optional)
args.node = dom.byId(args.node);
var fArgs = _mixin({ properties: {} }, args),
props = (fArgs.properties.opacity = {});
props.start = !("start" in fArgs) ?
function(){
return +style.get(fArgs.node, "opacity")||0;
} : fArgs.start;
props.end = fArgs.end;
var anim = dojo.animateProperty(fArgs);
connect.connect(anim, "beforeBegin", lang.partial(_makeFadeable, fArgs.node));
return anim; // dojo.Animation
};
/*=====
dojo.__FadeArgs = function(node, duration, easing){
// node: DOMNode|String
// The node referenced in the animation
// duration: Integer?
// Duration of the animation in milliseconds.
// easing: Function?
// An easing function.
this.node = node;
this.duration = duration;
this.easing = easing;
}
=====*/
dojo.fadeIn = function(/*dojo.__FadeArgs*/ args){
// summary:
// Returns an animation that will fade node defined in 'args' from
// its current opacity to fully opaque.
return dojo._fade(_mixin({ end: 1 }, args)); // dojo.Animation
};
dojo.fadeOut = function(/*dojo.__FadeArgs*/ args){
// summary:
// Returns an animation that will fade node defined in 'args'
// from its current opacity to fully transparent.
return dojo._fade(_mixin({ end: 0 }, args)); // dojo.Animation
};
dojo._defaultEasing = function(/*Decimal?*/ n){
// summary: The default easing function for dojo.Animation(s)
return 0.5 + ((Math.sin((n + 1.5) * Math.PI)) / 2); // Decimal
};
var PropLine = function(properties){
// PropLine is an internal class which is used to model the values of
// an a group of CSS properties across an animation lifecycle. In
// particular, the "getValue" function handles getting interpolated
// values between start and end for a particular CSS value.
this._properties = properties;
for(var p in properties){
var prop = properties[p];
if(prop.start instanceof Color){
// create a reusable temp color object to keep intermediate results
prop.tempColor = new Color();
}
}
};
PropLine.prototype.getValue = function(r){
var ret = {};
for(var p in this._properties){
var prop = this._properties[p],
start = prop.start;
if(start instanceof Color){
ret[p] = Color.blendColors(start, prop.end, r, prop.tempColor).toCss();
}else if(!lang.isArray(start)){
ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units || "px" : 0);
}
}
return ret;
};
/*=====
dojo.declare("dojo.__AnimArgs", [dojo.__FadeArgs], {
// Properties: Object?
// A hash map of style properties to Objects describing the transition,
// such as the properties of dojo._Line with an additional 'units' property
properties: {}
//TODOC: add event callbacks
});
=====*/
dojo.animateProperty = function(/*dojo.__AnimArgs*/ args){
// summary:
// Returns an animation that will transition the properties of
// node defined in `args` depending how they are defined in
// `args.properties`
//
// description:
// `dojo.animateProperty` is the foundation of most `dojo.fx`
// animations. It takes an object of "properties" corresponding to
// style properties, and animates them in parallel over a set
// duration.
//
// example:
// A simple animation that changes the width of the specified node.
// | dojo.animateProperty({
// | node: "nodeId",
// | properties: { width: 400 },
// | }).play();
// Dojo figures out the start value for the width and converts the
// integer specified for the width to the more expressive but
// verbose form `{ width: { end: '400', units: 'px' } }` which you
// can also specify directly. Defaults to 'px' if ommitted.
//
// example:
// Animate width, height, and padding over 2 seconds... the
// pedantic way:
// | dojo.animateProperty({ node: node, duration:2000,
// | properties: {
// | width: { start: '200', end: '400', units:"px" },
// | height: { start:'200', end: '400', units:"px" },
// | paddingTop: { start:'5', end:'50', units:"px" }
// | }
// | }).play();
// Note 'paddingTop' is used over 'padding-top'. Multi-name CSS properties
// are written using "mixed case", as the hyphen is illegal as an object key.
//
// example:
// Plug in a different easing function and register a callback for
// when the animation ends. Easing functions accept values between
// zero and one and return a value on that basis. In this case, an
// exponential-in curve.
// | dojo.animateProperty({
// | node: "nodeId",
// | // dojo figures out the start value
// | properties: { width: { end: 400 } },
// | easing: function(n){
// | return (n==0) ? 0 : Math.pow(2, 10 * (n - 1));
// | },
// | onEnd: function(node){
// | // called when the animation finishes. The animation
// | // target is passed to this function
// | }
// | }).play(500); // delay playing half a second
//
// example:
// Like all `dojo.Animation`s, animateProperty returns a handle to the
// Animation instance, which fires the events common to Dojo FX. Use `dojo.connect`
// to access these events outside of the Animation definiton:
// | var anim = dojo.animateProperty({
// | node:"someId",
// | properties:{
// | width:400, height:500
// | }
// | });
// | dojo.connect(anim,"onEnd", function(){
// | console.log("animation ended");
// | });
// | // play the animation now:
// | anim.play();
//
// example:
// Each property can be a function whose return value is substituted along.
// Additionally, each measurement (eg: start, end) can be a function. The node
// reference is passed direcly to callbacks.
// | dojo.animateProperty({
// | node:"mine",
// | properties:{
// | height:function(node){
// | // shrink this node by 50%
// | return dojo.position(node).h / 2
// | },
// | width:{
// | start:function(node){ return 100; },
// | end:function(node){ return 200; }
// | }
// | }
// | }).play();
//
var n = args.node = dom.byId(args.node);
if(!args.easing){ args.easing = dojo._defaultEasing; }
var anim = new dojo.Animation(args);
connect.connect(anim, "beforeBegin", anim, function(){
var pm = {};
for(var p in this.properties){
// Make shallow copy of properties into pm because we overwrite
// some values below. In particular if start/end are functions
// we don't want to overwrite them or the functions won't be
// called if the animation is reused.
if(p == "width" || p == "height"){
this.node.display = "block";
}
var prop = this.properties[p];
if(lang.isFunction(prop)){
prop = prop(n);
}
prop = pm[p] = _mixin({}, (lang.isObject(prop) ? prop: { end: prop }));
if(lang.isFunction(prop.start)){
prop.start = prop.start(n);
}
if(lang.isFunction(prop.end)){
prop.end = prop.end(n);
}
var isColor = (p.toLowerCase().indexOf("color") >= 0);
function getStyle(node, p){
// dojo.style(node, "height") can return "auto" or "" on IE; this is more reliable:
var v = { height: node.offsetHeight, width: node.offsetWidth }[p];
if(v !== undefined){ return v; }
v = style.get(node, p);
return (p == "opacity") ? +v : (isColor ? v : parseFloat(v));
}
if(!("end" in prop)){
prop.end = getStyle(n, p);
}else if(!("start" in prop)){
prop.start = getStyle(n, p);
}
if(isColor){
prop.start = new Color(prop.start);
prop.end = new Color(prop.end);
}else{
prop.start = (p == "opacity") ? +prop.start : parseFloat(prop.start);
}
}
this.curve = new PropLine(pm);
});
connect.connect(anim, "onAnimate", lang.hitch(style, "set", anim.node));
return anim; // dojo.Animation
};
dojo.anim = function( /*DOMNode|String*/ node,
/*Object*/ properties,
/*Integer?*/ duration,
/*Function?*/ easing,
/*Function?*/ onEnd,
/*Integer?*/ delay){
// summary:
// A simpler interface to `dojo.animateProperty()`, also returns
// an instance of `dojo.Animation` but begins the animation
// immediately, unlike nearly every other Dojo animation API.
// description:
// `dojo.anim` is a simpler (but somewhat less powerful) version
// of `dojo.animateProperty`. It uses defaults for many basic properties
// and allows for positional parameters to be used in place of the
// packed "property bag" which is used for other Dojo animation
// methods.
//
// The `dojo.Animation` object returned from `dojo.anim` will be
// already playing when it is returned from this function, so
// calling play() on it again is (usually) a no-op.
// node:
// a DOM node or the id of a node to animate CSS properties on
// duration:
// The number of milliseconds over which the animation
// should run. Defaults to the global animation default duration
// (350ms).
// easing:
// An easing function over which to calculate acceleration
// and deceleration of the animation through its duration.
// A default easing algorithm is provided, but you may
// plug in any you wish. A large selection of easing algorithms
// are available in `dojo.fx.easing`.
// onEnd:
// A function to be called when the animation finishes
// running.
// delay:
// The number of milliseconds to delay beginning the
// animation by. The default is 0.
// example:
// Fade out a node
// | dojo.anim("id", { opacity: 0 });
// example:
// Fade out a node over a full second
// | dojo.anim("id", { opacity: 0 }, 1000);
return dojo.animateProperty({ // dojo.Animation
node: node,
duration: duration || dojo.Animation.prototype.duration,
properties: properties,
easing: easing,
onEnd: onEnd
}).play(delay || 0);
};
return {
_Line: dojo._Line,
Animation: dojo.Animation,
_fade: dojo._fade,
fadeIn: dojo.fadeIn,
fadeOut: dojo.fadeOut,
_defaultEasing: dojo._defaultEasing,
animateProperty: dojo.animateProperty,
anim: dojo.anim
};
});

389
lib/dojo/_base/html.js.uncompressed.js
View File

@@ -1,389 +0,0 @@
define("dojo/_base/html", ["./kernel", "../dom", "../dom-style", "../dom-attr", "../dom-prop", "../dom-class", "../dom-construct", "../dom-geometry"], function(dojo, dom, style, attr, prop, cls, ctr, geom){
// module:
// dojo/dom
// summary:
// This module is a stub for the core dojo DOM API.
// mix-in dom
dojo.byId = dom.byId;
dojo.isDescendant = dom.isDescendant;
dojo.setSelectable = dom.setSelectable;
// mix-in dom-attr
dojo.getAttr = attr.get;
dojo.setAttr = attr.set;
dojo.hasAttr = attr.has;
dojo.removeAttr = attr.remove;
dojo.getNodeProp = attr.getNodeProp;
dojo.attr = function(node, name, value){
// summary:
// Gets or sets an attribute on an HTML element.
// description:
// Handles normalized getting and setting of attributes on DOM
// Nodes. If 2 arguments are passed, and a the second argument is a
// string, acts as a getter.
//
// If a third argument is passed, or if the second argument is a
// map of attributes, acts as a setter.
//
// When passing functions as values, note that they will not be
// directly assigned to slots on the node, but rather the default
// behavior will be removed and the new behavior will be added
// using `dojo.connect()`, meaning that event handler properties
// will be normalized and that some caveats with regards to
// non-standard behaviors for onsubmit apply. Namely that you
// should cancel form submission using `dojo.stopEvent()` on the
// passed event object instead of returning a boolean value from
// the handler itself.
// node: DOMNode|String
// id or reference to the element to get or set the attribute on
// name: String|Object
// the name of the attribute to get or set.
// value: String?
// The value to set for the attribute
// returns:
// when used as a getter, the value of the requested attribute
// or null if that attribute does not have a specified or
// default value;
//
// when used as a setter, the DOM node
//
// example:
// | // get the current value of the "foo" attribute on a node
// | dojo.attr(dojo.byId("nodeId"), "foo");
// | // or we can just pass the id:
// | dojo.attr("nodeId", "foo");
//
// example:
// | // use attr() to set the tab index
// | dojo.attr("nodeId", "tabIndex", 3);
// |
//
// example:
// Set multiple values at once, including event handlers:
// | dojo.attr("formId", {
// | "foo": "bar",
// | "tabIndex": -1,
// | "method": "POST",
// | "onsubmit": function(e){
// | // stop submitting the form. Note that the IE behavior
// | // of returning true or false will have no effect here
// | // since our handler is connect()ed to the built-in
// | // onsubmit behavior and so we need to use
// | // dojo.stopEvent() to ensure that the submission
// | // doesn't proceed.
// | dojo.stopEvent(e);
// |
// | // submit the form with Ajax
// | dojo.xhrPost({ form: "formId" });
// | }
// | });
//
// example:
// Style is s special case: Only set with an object hash of styles
// | dojo.attr("someNode",{
// | id:"bar",
// | style:{
// | width:"200px", height:"100px", color:"#000"
// | }
// | });
//
// example:
// Again, only set style as an object hash of styles:
// | var obj = { color:"#fff", backgroundColor:"#000" };
// | dojo.attr("someNode", "style", obj);
// |
// | // though shorter to use `dojo.style()` in this case:
// | dojo.style("someNode", obj);
if(arguments.length == 2){
return attr[typeof name == "string" ? "get" : "set"](node, name);
}
return attr.set(node, name, value);
};
// mix-in dom-class
dojo.hasClass = cls.contains;
dojo.addClass = cls.add;
dojo.removeClass = cls.remove;
dojo.toggleClass = cls.toggle;
dojo.replaceClass = cls.replace;
// mix-in dom-construct
dojo._toDom = dojo.toDom = ctr.toDom;
dojo.place = ctr.place;
dojo.create = ctr.create;
dojo.empty = function(node){ ctr.empty(node); };
dojo._destroyElement = dojo.destroy = function(node){ ctr.destroy(node); };
// mix-in dom-geometry
dojo._getPadExtents = dojo.getPadExtents = geom.getPadExtents;
dojo._getBorderExtents = dojo.getBorderExtents = geom.getBorderExtents;
dojo._getPadBorderExtents = dojo.getPadBorderExtents = geom.getPadBorderExtents;
dojo._getMarginExtents = dojo.getMarginExtents = geom.getMarginExtents;
dojo._getMarginSize = dojo.getMarginSize = geom.getMarginSize;
dojo._getMarginBox = dojo.getMarginBox = geom.getMarginBox;
dojo.setMarginBox = geom.setMarginBox;
dojo._getContentBox = dojo.getContentBox = geom.getContentBox;
dojo.setContentSize = geom.setContentSize;
dojo._isBodyLtr = dojo.isBodyLtr = geom.isBodyLtr;
dojo._docScroll = dojo.docScroll = geom.docScroll;
dojo._getIeDocumentElementOffset = dojo.getIeDocumentElementOffset = geom.getIeDocumentElementOffset;
dojo._fixIeBiDiScrollLeft = dojo.fixIeBiDiScrollLeft = geom.fixIeBiDiScrollLeft;
dojo.position = geom.position;
dojo.marginBox = function marginBox(/*DomNode|String*/node, /*Object?*/box){
// summary:
// Getter/setter for the margin-box of node.
// description:
// Getter/setter for the margin-box of node.
// Returns an object in the expected format of box (regardless
// if box is passed). The object might look like:
// `{ l: 50, t: 200, w: 300: h: 150 }`
// for a node offset from its parent 50px to the left, 200px from
// the top with a margin width of 300px and a margin-height of
// 150px.
// node:
// id or reference to DOM Node to get/set box for
// box:
// If passed, denotes that dojo.marginBox() should
// update/set the margin box for node. Box is an object in the
// above format. All properties are optional if passed.
// example:
// Retrieve the margin box of a passed node
// | var box = dojo.marginBox("someNodeId");
// | console.dir(box);
//
// example:
// Set a node's margin box to the size of another node
// | var box = dojo.marginBox("someNodeId");
// | dojo.marginBox("someOtherNode", box);
return box ? geom.setMarginBox(node, box) : geom.getMarginBox(node); // Object
};
dojo.contentBox = function contentBox(/*DomNode|String*/node, /*Object?*/box){
// summary:
// Getter/setter for the content-box of node.
// description:
// Returns an object in the expected format of box (regardless if box is passed).
// The object might look like:
// `{ l: 50, t: 200, w: 300: h: 150 }`
// for a node offset from its parent 50px to the left, 200px from
// the top with a content width of 300px and a content-height of
// 150px. Note that the content box may have a much larger border
// or margin box, depending on the box model currently in use and
// CSS values set/inherited for node.
// While the getter will return top and left values, the
// setter only accepts setting the width and height.
// node:
// id or reference to DOM Node to get/set box for
// box:
// If passed, denotes that dojo.contentBox() should
// update/set the content box for node. Box is an object in the
// above format, but only w (width) and h (height) are supported.
// All properties are optional if passed.
return box ? geom.setContentSize(node, box) : geom.getContentBox(node); // Object
};
dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){
// summary:
// Deprecated: Use position() for border-box x/y/w/h
// or marginBox() for margin-box w/h/l/t.
// Returns an object representing a node's size and position.
//
// description:
// Returns an object that measures margin-box (w)idth/(h)eight
// and absolute position x/y of the border-box. Also returned
// is computed (l)eft and (t)op values in pixels from the
// node's offsetParent as returned from marginBox().
// Return value will be in the form:
//| { l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 }
// Does not act as a setter. If includeScroll is passed, the x and
// y params are affected as one would expect in dojo.position().
dojo.deprecated("dojo.coords()", "Use dojo.position() or dojo.marginBox().");
node = dom.byId(node);
var s = style.getComputedStyle(node), mb = geom.getMarginBox(node, s);
var abs = geom.position(node, includeScroll);
mb.x = abs.x;
mb.y = abs.y;
return mb; // Object
};
// mix-in dom-prop
dojo.getProp = prop.get;
dojo.setProp = prop.set;
dojo.prop = function(/*DomNode|String*/node, /*String|Object*/name, /*String?*/value){
// summary:
// Gets or sets a property on an HTML element.
// description:
// Handles normalized getting and setting of properties on DOM
// Nodes. If 2 arguments are passed, and a the second argument is a
// string, acts as a getter.
//
// If a third argument is passed, or if the second argument is a
// map of attributes, acts as a setter.
//
// When passing functions as values, note that they will not be
// directly assigned to slots on the node, but rather the default
// behavior will be removed and the new behavior will be added
// using `dojo.connect()`, meaning that event handler properties
// will be normalized and that some caveats with regards to
// non-standard behaviors for onsubmit apply. Namely that you
// should cancel form submission using `dojo.stopEvent()` on the
// passed event object instead of returning a boolean value from
// the handler itself.
// node:
// id or reference to the element to get or set the property on
// name:
// the name of the property to get or set.
// value:
// The value to set for the property
// returns:
// when used as a getter, the value of the requested property
// or null if that attribute does not have a specified or
// default value;
//
// when used as a setter, the DOM node
//
// example:
// | // get the current value of the "foo" property on a node
// | dojo.prop(dojo.byId("nodeId"), "foo");
// | // or we can just pass the id:
// | dojo.prop("nodeId", "foo");
//
// example:
// | // use prop() to set the tab index
// | dojo.prop("nodeId", "tabIndex", 3);
// |
//
// example:
// Set multiple values at once, including event handlers:
// | dojo.prop("formId", {
// | "foo": "bar",
// | "tabIndex": -1,
// | "method": "POST",
// | "onsubmit": function(e){
// | // stop submitting the form. Note that the IE behavior
// | // of returning true or false will have no effect here
// | // since our handler is connect()ed to the built-in
// | // onsubmit behavior and so we need to use
// | // dojo.stopEvent() to ensure that the submission
// | // doesn't proceed.
// | dojo.stopEvent(e);
// |
// | // submit the form with Ajax
// | dojo.xhrPost({ form: "formId" });
// | }
// | });
//
// example:
// Style is s special case: Only set with an object hash of styles
// | dojo.prop("someNode",{
// | id:"bar",
// | style:{
// | width:"200px", height:"100px", color:"#000"
// | }
// | });
//
// example:
// Again, only set style as an object hash of styles:
// | var obj = { color:"#fff", backgroundColor:"#000" };
// | dojo.prop("someNode", "style", obj);
// |
// | // though shorter to use `dojo.style()` in this case:
// | dojo.style("someNode", obj);
if(arguments.length == 2){
return prop[typeof name == "string" ? "get" : "set"](node, name);
}
// setter
return prop.set(node, name, value);
};
// mix-in dom-style
dojo.getStyle = style.get;
dojo.setStyle = style.set;
dojo.getComputedStyle = style.getComputedStyle;
dojo.__toPixelValue = dojo.toPixelValue = style.toPixelValue;
dojo.style = function(node, name, value){
// summary:
// Accesses styles on a node. If 2 arguments are
// passed, acts as a getter. If 3 arguments are passed, acts
// as a setter.
// description:
// Getting the style value uses the computed style for the node, so the value
// will be a calculated value, not just the immediate node.style value.
// Also when getting values, use specific style names,
// like "borderBottomWidth" instead of "border" since compound values like
// "border" are not necessarily reflected as expected.
// If you want to get node dimensions, use `dojo.marginBox()`,
// `dojo.contentBox()` or `dojo.position()`.
// node: DOMNode|String
// id or reference to node to get/set style for
// name: String?|Object?
// the style property to set in DOM-accessor format
// ("borderWidth", not "border-width") or an object with key/value
// pairs suitable for setting each property.
// value: String?
// If passed, sets value on the node for style, handling
// cross-browser concerns. When setting a pixel value,
// be sure to include "px" in the value. For instance, top: "200px".
// Otherwise, in some cases, some browsers will not apply the style.
// returns:
// when used as a getter, return the computed style of the node if passing in an ID or node,
// or return the normalized, computed value for the property when passing in a node and a style property
// example:
// Passing only an ID or node returns the computed style object of
// the node:
// | dojo.style("thinger");
// example:
// Passing a node and a style property returns the current
// normalized, computed value for that property:
// | dojo.style("thinger", "opacity"); // 1 by default
//
// example:
// Passing a node, a style property, and a value changes the
// current display of the node and returns the new computed value
// | dojo.style("thinger", "opacity", 0.5); // == 0.5
//
// example:
// Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
// | dojo.style("thinger", {
// | "opacity": 0.5,
// | "border": "3px solid black",
// | "height": "300px"
// | });
//
// example:
// When the CSS style property is hyphenated, the JavaScript property is camelCased.
// font-size becomes fontSize, and so on.
// | dojo.style("thinger",{
// | fontSize:"14pt",
// | letterSpacing:"1.2em"
// | });
//
// example:
// dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
// dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()`
// | dojo.query(".someClassName").style("visibility","hidden");
// | // or
// | dojo.query("#baz > div").style({
// | opacity:0.75,
// | fontSize:"13pt"
// | });
switch(arguments.length){
case 1:
return style.get(node);
case 2:
return style[typeof name == "string" ? "get" : "set"](node, name);
}
// setter
return style.set(node, name, value);
};
return dojo;
});

85
lib/dojo/_base/json.js.uncompressed.js
View File

@@ -1,85 +0,0 @@
define("dojo/_base/json", ["./kernel", "../json"], function(dojo, json){
// module:
// dojo/_base/json
// summary:
// This module defines the dojo JSON API.
dojo.fromJson = function(/*String*/ js){
// summary:
// Parses a JavaScript expression and returns a JavaScript value.
// description:
// Throws for invalid JavaScript expressions. It does not use a strict JSON parser. It
// always delegates to eval(). The content passed to this method must therefore come
// from a trusted source.
// It is recommend that you use dojo/json's parse function for an
// implementation uses the (faster) native JSON parse when available.
// js:
// a string literal of a JavaScript expression, for instance:
// `'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
return eval("(" + js + ")"); // Object
};
/*=====
dojo._escapeString = function(){
// summary:
// Adds escape sequences for non-visual characters, double quote and
// backslash and surrounds with double quotes to form a valid string
// literal.
};
=====*/
dojo._escapeString = json.stringify; // just delegate to json.stringify
dojo.toJsonIndentStr = "\t";
dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint){
// summary:
// Returns a [JSON](http://json.org) serialization of an object.
// description:
// Returns a [JSON](http://json.org) serialization of an object.
// Note that this doesn't check for infinite recursion, so don't do that!
// It is recommend that you use dojo/json's stringify function for an lighter
// and faster implementation that matches the native JSON API and uses the
// native JSON serializer when available.
// it:
// an object to be serialized. Objects may define their own
// serialization via a special "__json__" or "json" function
// property. If a specialized serializer has been defined, it will
// be used as a fallback.
// Note that in 1.6, toJson would serialize undefined, but this no longer supported
// since it is not supported by native JSON serializer.
// prettyPrint:
// if true, we indent objects and arrays to make the output prettier.
// The variable `dojo.toJsonIndentStr` is used as the indent string --
// to use something other than the default (tab), change that variable
// before calling dojo.toJson().
// Note that if native JSON support is available, it will be used for serialization,
// and native implementations vary on the exact spacing used in pretty printing.
// returns:
// A JSON string serialization of the passed-in object.
// example:
// simple serialization of a trivial object
// | var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true });
// | doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
// example:
// a custom serializer for an objects of a particular class:
// | dojo.declare("Furby", null, {
// | furbies: "are strange",
// | furbyCount: 10,
// | __json__: function(){
// | },
// | });
// use dojo/json
return json.stringify(it, function(key, value){
if(value){
var tf = value.__json__||value.json;
if(typeof tf == "function"){
return tf.call(value);
}
}
return value;
}, prettyPrint && dojo.toJsonIndentStr); // String
};
return dojo;
});

302
lib/dojo/_base/kernel.js.uncompressed.js
View File

@@ -1,302 +0,0 @@
define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){
// module:
// dojo/_base/kernel
// summary:
// This module is the foundational module of the dojo boot sequence; it defines the dojo object.
var
// loop variables for this module
i, p,
// create dojo, dijit, and dojox
// FIXME: in 2.0 remove dijit, dojox being created by dojo
dijit = {},
dojox = {},
dojo = {
// notice dojo takes ownership of the value of the config module
config:config,
global:this,
dijit:dijit,
dojox:dojox
};
// Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide
// a _scopeName property for the dojo, dijit, and dojox root object so those packages can create
// unique names in the global space.
//
// Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox,
// where global when in fact they are either global under different names or not global at all. In v1.6-, the
// config variable "scopeMap" was used to map names as used within a module to global names. This has been
// subsumed by the dojo packageMap configuration variable which relocates packages to different names. See
// http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details.
//
// The following computations contort the packageMap for this dojo instance into a scopeMap.
var scopeMap =
// a map from a name used in a legacy module to the (global variable name, object addressed by that name)
// always map dojo, dijit, and dojox
{
dojo:["dojo", dojo],
dijit:["dijit", dijit],
dojox:["dojox", dojox]
},
packageMap =
// the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config
(require.packs && require.packs[module.id.match(/[^\/]+/)[0]].packageMap) || {},
item;
// process all mapped top-level names for this instance of dojo
for(p in packageMap){
if(scopeMap[p]){
// mapped dojo, dijit, or dojox
scopeMap[p][0] = packageMap[p];
}else{
// some other top-level name
scopeMap[p] = [packageMap[p], {}];
}
}
// publish those names to _scopeName and, optionally, the global namespace
for(p in scopeMap){
item = scopeMap[p];
item[1]._scopeName = item[0];
if(!config.noGlobals){
this[item[0]] = item[1];
}
}
dojo.scopeMap = scopeMap;
// FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated
dojo.baseUrl = dojo.config.baseUrl = require.baseUrl;
dojo.isAsync = !1 || require.async;
dojo.locale = config.locale;
/*=====
dojo.version = function(){
// summary:
// Version number of the Dojo Toolkit
// major: Integer
// Major version. If total version is "1.2.0beta1", will be 1
// minor: Integer
// Minor version. If total version is "1.2.0beta1", will be 2
// patch: Integer
// Patch version. If total version is "1.2.0beta1", will be 0
// flag: String
// Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
// revision: Number
// The SVN rev from which dojo was pulled
this.major = 0;
this.minor = 0;
this.patch = 0;
this.flag = "";
this.revision = 0;
}
=====*/
var rev = "$Rev: 28982 $".match(/\d+/);
dojo.version = {
major: 1, minor: 7, patch: 3, flag: "",
revision: rev ? +rev[0] : NaN,
toString: function(){
var v = dojo.version;
return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")"; // String
}
};
// If 1 is truthy, then as a dojo module is defined it should push it's definitions
// into the dojo object, and conversely. In 2.0, it will likely be unusual to augment another object
// as a result of defining a module. This has feature gives a way to force 2.0 behavior as the code
// is migrated. Absent specific advice otherwise, set extend-dojo to truthy.
true || has.add("extend-dojo", 1);
dojo.eval = function(scriptText){
// summary:
// A legacy method created for use exclusively by internal Dojo methods. Do not use this method
// directly unless you understand its possibly-different implications on the platforms your are targeting.
// description:
// Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers
// that support indirect eval.
//
// As usual, IE does not. On IE, the only way to implement global eval is to
// use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval.
// This implementation uses the technique of executing eval in the scope of a function that is a single scope
// frame below the global scope; thereby coming close to the global scope. Note carefully that
//
// dojo.eval("var pi = 3.14;");
//
// will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want
// to define a global variable using dojo.eval, write something like
//
// dojo.eval("window.pi = 3.14;")
// scriptText:
// The text to evaluation.
// returns:
// The result of the evaluation. Often `undefined`
};
(Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
if(0){
dojo.exit = function(exitcode){
quit(exitcode);
};
} else{
dojo.exit = function(){
};
}
true || has.add("dojo-guarantee-console",
// ensure that console.log, console.warn, etc. are defined
1
);
if(1){
typeof console != "undefined" || (console = {});
// Be careful to leave 'log' always at the end
var cn = [
"assert", "count", "debug", "dir", "dirxml", "error", "group",
"groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
"trace", "warn", "log"
];
var tn;
i = 0;
while((tn = cn[i++])){
if(!console[tn]){
(function(){
var tcn = tn + "";
console[tcn] = ('log' in console) ? function(){
var a = Array.apply({}, arguments);
a.unshift(tcn + ":");
console["log"](a.join(" "));
} : function(){};
console[tcn]._fake = true;
})();
}
}
}
has.add("dojo-debug-messages",
// include dojo.deprecated/dojo.experimental implementations
!!config.isDebug
);
if(has("dojo-debug-messages")){
dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
// summary:
// Log a debug message to indicate that a behavior has been
// deprecated.
// behaviour: String
// The API or behavior being deprecated. Usually in the form
// of "myApp.someFunction()".
// extra: String?
// Text to append to the message. Often provides advice on a
// new function or facility to achieve the same goal during
// the deprecation period.
// removal: String?
// Text to indicate when in the future the behavior will be
// removed. Usually a version number.
// example:
// | dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");
var message = "DEPRECATED: " + behaviour;
if(extra){ message += " " + extra; }
if(removal){ message += " -- will be removed in version: " + removal; }
console.warn(message);
};
dojo.experimental = function(/* String */ moduleName, /* String? */ extra){
// summary: Marks code as experimental.
// description:
// This can be used to mark a function, file, or module as
// experimental. Experimental code is not ready to be used, and the
// APIs are subject to change without notice. Experimental code may be
// completed deleted without going through the normal deprecation
// process.
// moduleName: String
// The name of a module, or the name of a module file or a specific
// function
// extra: String?
// some additional message for the user
// example:
// | dojo.experimental("dojo.data.Result");
// example:
// | dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");
var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice.";
if(extra){ message += " " + extra; }
console.warn(message);
};
}else{
dojo.deprecated = dojo.experimental = function(){};
}
true || has.add("dojo-modulePaths",
// consume dojo.modulePaths processing
1
);
if(1){
// notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run;
// this is the v1.6- behavior.
if(config.modulePaths){
dojo.deprecated("dojo.modulePaths", "use paths configuration");
var paths = {};
for(p in config.modulePaths){
paths[p.replace(/\./g, "/")] = config.modulePaths[p];
}
require({paths:paths});
}
}
true || has.add("dojo-moduleUrl",
// include dojo.moduleUrl
1
);
if(1){
dojo.moduleUrl = function(/*String*/module, /*String?*/url){
// summary:
// Returns a URL relative to a module.
// example:
// | var pngPath = dojo.moduleUrl("acme","images/small.png");
// | console.dir(pngPath); // list the object properties
// | // create an image and set it's source to pngPath's value:
// | var img = document.createElement("img");
// | img.src = pngPath;
// | // add our image to the document
// | dojo.body().appendChild(img);
// example:
// you may de-reference as far as you like down the package
// hierarchy. This is sometimes handy to avoid lenghty relative
// urls or for building portable sub-packages. In this example,
// the `acme.widget` and `acme.util` directories may be located
// under different roots (see `dojo.registerModulePath`) but the
// the modules which reference them can be unaware of their
// relative locations on the filesystem:
// | // somewhere in a configuration block
// | dojo.registerModulePath("acme.widget", "../../acme/widget");
// | dojo.registerModulePath("acme.util", "../../util");
// |
// | // ...
// |
// | // code in a module using acme resources
// | var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
// | var dataPath = dojo.moduleUrl("acme.util","resources/data.json");
dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0");
// require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then
// remove the suffix from the result. This way clients can request a url w/out a filetype. This should be
// rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0).
// Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config.
var result = null;
if(module){
result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/");
}
return result;
};
}
dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling
return dojo;
});

707
lib/dojo/_base/lang.js.uncompressed.js
View File

@@ -1,707 +0,0 @@
define("dojo/_base/lang", ["./kernel", "../has", "./sniff"], function(dojo, has){
// module:
// dojo/_base/lang
// summary:
// This module defines Javascript language extensions.
has.add("bug-for-in-skips-shadowed", function(){
// if true, the for-in interator skips object properties that exist in Object's prototype (IE 6 - ?)
for(var i in {toString: 1}){
return 0;
}
return 1;
});
var _extraNames =
has("bug-for-in-skips-shadowed") ?
"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split(".") : [],
_extraLen = _extraNames.length,
_mixin = function(dest, source, copyFunc){
var name, s, i, empty = {};
for(name in source){
// the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source"
// inherited from Object.prototype. For example, if dest has a custom toString() method,
// don't overwrite it with the toString() method that source inherited from Object.prototype
s = source[name];
if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
dest[name] = copyFunc ? copyFunc(s) : s;
}
}
if(has("bug-for-in-skips-shadowed")){
if(source){
for(i = 0; i < _extraLen; ++i){
name = _extraNames[i];
s = source[name];
if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
dest[name] = copyFunc ? copyFunc(s) : s;
}
}
}
}
return dest; // Object
},
mixin = function(dest, sources){
if(!dest){ dest = {}; }
for(var i = 1, l = arguments.length; i < l; i++){
lang._mixin(dest, arguments[i]);
}
return dest; // Object
},
getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){
var p, i = 0, dojoGlobal = dojo.global;
if(!context){
if(!parts.length){
return dojoGlobal;
}else{
p = parts[i++];
try{
context = dojo.scopeMap[p] && dojo.scopeMap[p][1];
}catch(e){}
context = context || (p in dojoGlobal ? dojoGlobal[p] : (create ? dojoGlobal[p] = {} : undefined));
}
}
while(context && (p = parts[i++])){
context = (p in context ? context[p] : (create ? context[p] = {} : undefined));
}
return context; // mixed
},
setObject = function(name, value, context){
var parts = name.split("."), p = parts.pop(), obj = getProp(parts, true, context);
return obj && p ? (obj[p] = value) : undefined; // Object
},
getObject = function(name, create, context){
return getProp(name.split("."), create, context); // Object
},
exists = function(name, obj){
return lang.getObject(name, false, obj) !== undefined; // Boolean
},
opts = Object.prototype.toString,
// Crockford (ish) functions
isString = function(it){
return (typeof it == "string" || it instanceof String); // Boolean
},
isArray = function(it){
return it && (it instanceof Array || typeof it == "array"); // Boolean
},
isFunction = function(it){
return opts.call(it) === "[object Function]";
},
isObject = function(it){
return it !== undefined &&
(it === null || typeof it == "object" || lang.isArray(it) || lang.isFunction(it)); // Boolean
},
isArrayLike = function(it){
return it && it !== undefined && // Boolean
// keep out built-in constructors (Number, String, ...) which have length
// properties
!lang.isString(it) && !lang.isFunction(it) &&
!(it.tagName && it.tagName.toLowerCase() == 'form') &&
(lang.isArray(it) || isFinite(it.length));
},
isAlien = function(it){
return it && !lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
},
extend = function(constructor, props){
for(var i=1, l=arguments.length; i<l; i++){
lang._mixin(constructor.prototype, arguments[i]);
}
return constructor; // Object
},
_hitchArgs = function(scope, method){
var pre = _toArray(arguments, 2);
var named = lang.isString(method);
return function(){
// arrayify arguments
var args = _toArray(arguments);
// locate our method
var f = named ? (scope||dojo.global)[method] : method;
// invoke with collected args
return f && f.apply(scope || this, pre.concat(args)); // mixed
}; // Function
},
hitch = function(scope, method){
if(arguments.length > 2){
return lang._hitchArgs.apply(dojo, arguments); // Function
}
if(!method){
method = scope;
scope = null;
}
if(lang.isString(method)){
scope = scope || dojo.global;
if(!scope[method]){ throw(['dojo.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
return function(){ return scope[method].apply(scope, arguments || []); }; // Function
}
return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
},
delegate = (function(){
// boodman/crockford delegation w/ cornford optimization
function TMP(){}
return function(obj, props){
TMP.prototype = obj;
var tmp = new TMP();
TMP.prototype = null;
if(props){
lang._mixin(tmp, props);
}
return tmp; // Object
};
})(),
efficient = function(obj, offset, startWith){
return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
},
_toArray =
has("ie") ?
(function(){
function slow(obj, offset, startWith){
var arr = startWith||[];
for(var x = offset || 0; x < obj.length; x++){
arr.push(obj[x]);
}
return arr;
}
return function(obj){
return ((obj.item) ? slow : efficient).apply(this, arguments);
};
})() : efficient,
partial = function(/*Function|String*/method /*, ...*/){
var arr = [ null ];
return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function
},
clone = function(/*anything*/ src){
if(!src || typeof src != "object" || lang.isFunction(src)){
// null, undefined, any non-object, or function
return src; // anything
}
if(src.nodeType && "cloneNode" in src){
// DOM Node
return src.cloneNode(true); // Node
}
if(src instanceof Date){
// Date
return new Date(src.getTime()); // Date
}
if(src instanceof RegExp){
// RegExp
return new RegExp(src); // RegExp
}
var r, i, l;
if(lang.isArray(src)){
// array
r = [];
for(i = 0, l = src.length; i < l; ++i){
if(i in src){
r.push(clone(src[i]));
}
}
// we don't clone functions for performance reasons
// }else if(d.isFunction(src)){
// // function
// r = function(){ return src.apply(this, arguments); };
}else{
// generic objects
r = src.constructor ? new src.constructor() : {};
}
return lang._mixin(r, src, clone);
},
trim = String.prototype.trim ?
function(str){ return str.trim(); } :
function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); },
_pattern = /\{([^\}]+)\}/g,
replace = function(tmpl, map, pattern){
return tmpl.replace(pattern || _pattern, lang.isFunction(map) ?
map : function(_, k){ return getObject(k, false, map); });
},
lang = {
_extraNames:_extraNames,
_mixin:_mixin,
mixin:mixin,
setObject:setObject,
getObject:getObject,
exists:exists,
isString:isString,
isArray:isArray,
isFunction:isFunction,
isObject:isObject,
isArrayLike:isArrayLike,
isAlien:isAlien,
extend:extend,
_hitchArgs:_hitchArgs,
hitch:hitch,
delegate:delegate,
_toArray:_toArray,
partial:partial,
clone:clone,
trim:trim,
replace:replace
};
1 && mixin(dojo, lang);
return lang;
/*=====
dojo._extraNames
// summary:
// Array of strings. Lists property names that must be explicitly processed during for-in interation
// in environments that have has("bug-for-in-skips-shadowed") true.
=====*/
/*=====
dojo._mixin = function(dest, source, copyFunc){
// summary:
// Copies/adds all properties of source to dest; returns dest.
// dest: Object:
// The object to which to copy/add all properties contained in source.
// source: Object:
// The object from which to draw all properties to copy into dest.
// copyFunc: Function?:
// The process used to copy/add a property in source; defaults to the Javascript assignment operator.
// returns:
// dest, as modified
// description:
// All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
// found in Object.prototype, are copied/added to dest. Copying/adding each particular property is
// delegated to copyFunc (if any); copyFunc defaults to the Javascript assignment operator if not provided.
// Notice that by default, _mixin executes a so-called "shallow copy" and aggregate types are copied/added by reference.
}
=====*/
/*=====
dojo.mixin = function(dest, sources){
// summary:
// Copies/adds all properties of one or more sources to dest; returns dest.
// dest: Object
// The object to which to copy/add all properties contained in source. If dest is falsy, then
// a new object is manufactured before copying/adding properties begins.
// sources: Object...
// One of more objects from which to draw all properties to copy into dest. sources are processed
// left-to-right and if more than one of these objects contain the same property name, the right-most
// value "wins".
// returns: Object
// dest, as modified
// description:
// All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
// found in Object.prototype, are copied/added from sources to dest. sources are processed left to right.
// The Javascript assignment operator is used to copy/add each property; therefore, by default, mixin
// executes a so-called "shallow copy" and aggregate types are copied/added by reference.
// example:
// make a shallow copy of an object
// | var copy = lang.mixin({}, source);
// example:
// many class constructors often take an object which specifies
// values to be configured on the object. In this case, it is
// often simplest to call `lang.mixin` on the `this` object:
// | dojo.declare("acme.Base", null, {
// | constructor: function(properties){
// | // property configuration:
// | lang.mixin(this, properties);
// |
// | console.log(this.quip);
// | // ...
// | },
// | quip: "I wasn't born yesterday, you know - I've seen movies.",
// | // ...
// | });
// |
// | // create an instance of the class and configure it
// | var b = new acme.Base({quip: "That's what it does!" });
// example:
// copy in properties from multiple objects
// | var flattened = lang.mixin(
// | {
// | name: "Frylock",
// | braces: true
// | },
// | {
// | name: "Carl Brutanananadilewski"
// | }
// | );
// |
// | // will print "Carl Brutanananadilewski"
// | console.log(flattened.name);
// | // will print "true"
// | console.log(flattened.braces);
}
=====*/
/*=====
dojo.setObject = function(name, value, context){
// summary:
// Set a property from a dot-separated string, such as "A.B.C"
// description:
// Useful for longer api chains where you have to test each object in
// the chain, or when you have an object reference in string format.
// Objects are created as needed along `path`. Returns the passed
// value if setting is successful or `undefined` if not.
// name: String
// Path to a property, in the form "A.B.C".
// value: anything
// value or object to place at location given by name
// context: Object?
// Optional. Object to use as root of path. Defaults to
// `dojo.global`.
// example:
// set the value of `foo.bar.baz`, regardless of whether
// intermediate objects already exist:
// | lang.setObject("foo.bar.baz", value);
// example:
// without `lang.setObject`, we often see code like this:
// | // ensure that intermediate objects are available
// | if(!obj["parent"]){ obj.parent = {}; }
// | if(!obj.parent["child"]){ obj.parent.child = {}; }
// | // now we can safely set the property
// | obj.parent.child.prop = "some value";
// whereas with `lang.setObject`, we can shorten that to:
// | lang.setObject("parent.child.prop", "some value", obj);
}
=====*/
/*=====
dojo.getObject = function(name, create, context){
// summary:
// Get a property from a dot-separated string, such as "A.B.C"
// description:
// Useful for longer api chains where you have to test each object in
// the chain, or when you have an object reference in string format.
// name: String
// Path to an property, in the form "A.B.C".
// create: Boolean?
// Optional. Defaults to `false`. If `true`, Objects will be
// created at any point along the 'path' that is undefined.
// context: Object?
// Optional. Object to use as root of path. Defaults to
// 'dojo.global'. Null may be passed.
}
=====*/
/*=====
dojo.exists = function(name, obj){
// summary:
// determine if an object supports a given method
// description:
// useful for longer api chains where you have to test each object in
// the chain. Useful for object and method detection.
// name: String
// Path to an object, in the form "A.B.C".
// obj: Object?
// Object to use as root of path. Defaults to
// 'dojo.global'. Null may be passed.
// example:
// | // define an object
// | var foo = {
// | bar: { }
// | };
// |
// | // search the global scope
// | lang.exists("foo.bar"); // true
// | lang.exists("foo.bar.baz"); // false
// |
// | // search from a particular scope
// | lang.exists("bar", foo); // true
// | lang.exists("bar.baz", foo); // false
}
=====*/
/*=====
dojo.isString = function(it){
// summary:
// Return true if it is a String
// it: anything
// Item to test.
}
=====*/
/*=====
dojo.isArray = function(it){
// summary:
// Return true if it is an Array.
// Does not work on Arrays created in other windows.
// it: anything
// Item to test.
}
=====*/
/*=====
dojo.isFunction = function(it){
// summary:
// Return true if it is a Function
// it: anything
// Item to test.
}
=====*/
/*=====
dojo.isObject = function(it){
// summary:
// Returns true if it is a JavaScript object (or an Array, a Function
// or null)
// it: anything
// Item to test.
}
=====*/
/*=====
dojo.isArrayLike = function(it){
// summary:
// similar to dojo.isArray() but more permissive
// it: anything
// Item to test.
// returns:
// If it walks like a duck and quacks like a duck, return `true`
// description:
// Doesn't strongly test for "arrayness". Instead, settles for "isn't
// a string or number and has a length property". Arguments objects
// and DOM collections will return true when passed to
// dojo.isArrayLike(), but will return false when passed to
// dojo.isArray().
}
=====*/
/*=====
dojo.isAlien = function(it){
// summary:
// Returns true if it is a built-in function or some other kind of
// oddball that *should* report as a function but doesn't
}
=====*/
/*=====
dojo.extend = function(constructor, props){
// summary:
// Adds all properties and methods of props to constructor's
// prototype, making them available to all instances created with
// constructor.
// constructor: Object
// Target constructor to extend.
// props: Object...
// One or more objects to mix into constructor.prototype
}
=====*/
/*=====
dojo.hitch = function(scope, method){
// summary:
// Returns a function that will only ever execute in the a given scope.
// This allows for easy use of object member functions
// in callbacks and other places in which the "this" keyword may
// otherwise not reference the expected scope.
// Any number of default positional arguments may be passed as parameters
// beyond "method".
// Each of these values will be used to "placehold" (similar to curry)
// for the hitched function.
// scope: Object
// The scope to use when method executes. If method is a string,
// scope is also the object containing method.
// method: Function|String...
// A function to be hitched to scope, or the name of the method in
// scope to be hitched.
// example:
// | dojo.hitch(foo, "bar")();
// runs foo.bar() in the scope of foo
// example:
// | dojo.hitch(foo, myFunction);
// returns a function that runs myFunction in the scope of foo
// example:
// Expansion on the default positional arguments passed along from
// hitch. Passed args are mixed first, additional args after.
// | var foo = { bar: function(a, b, c){ console.log(a, b, c); } };
// | var fn = dojo.hitch(foo, "bar", 1, 2);
// | fn(3); // logs "1, 2, 3"
// example:
// | var foo = { bar: 2 };
// | dojo.hitch(foo, function(){ this.bar = 10; })();
// execute an anonymous function in scope of foo
}
=====*/
/*=====
dojo.delegate = function(obj, props){
// summary:
// Returns a new object which "looks" to obj for properties which it
// does not have a value for. Optionally takes a bag of properties to
// seed the returned object with initially.
// description:
// This is a small implementaton of the Boodman/Crockford delegation
// pattern in JavaScript. An intermediate object constructor mediates
// the prototype chain for the returned object, using it to delegate
// down to obj for property lookup when object-local lookup fails.
// This can be thought of similarly to ES4's "wrap", save that it does
// not act on types but rather on pure objects.
// obj: Object
// The object to delegate to for properties not found directly on the
// return object or in props.
// props: Object...
// an object containing properties to assign to the returned object
// returns:
// an Object of anonymous type
// example:
// | var foo = { bar: "baz" };
// | var thinger = dojo.delegate(foo, { thud: "xyzzy"});
// | thinger.bar == "baz"; // delegated to foo
// | foo.thud == undefined; // by definition
// | thinger.thud == "xyzzy"; // mixed in from props
// | foo.bar = "thonk";
// | thinger.bar == "thonk"; // still delegated to foo's bar
}
=====*/
/*=====
dojo.partial = function(method){
// summary:
// similar to hitch() except that the scope object is left to be
// whatever the execution context eventually becomes.
// method: Function|String
// description:
// Calling dojo.partial is the functional equivalent of calling:
// | dojo.hitch(null, funcName, ...);
}
=====*/
/*=====
dojo.trim = function(str){
// summary:
// Trims whitespace from both sides of the string
// str: String
// String to be trimmed
// returns: String
// Returns the trimmed string
// description:
// This version of trim() was selected for inclusion into the base due
// to its compact size and relatively good performance
// (see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript)
// Uses String.prototype.trim instead, if available.
// The fastest but longest version of this function is located at
// dojo.string.trim()
}
=====*/
/*=====
dojo.clone = function(src){
// summary:
// Clones objects (including DOM nodes) and all children.
// Warning: do not clone cyclic structures.
// src:
// The object to clone
}
=====*/
/*=====
dojo._toArray = function(obj, offset, startWith){
// summary:
// Converts an array-like object (i.e. arguments, DOMCollection) to an
// array. Returns a new Array with the elements of obj.
// obj: Object
// the object to "arrayify". We expect the object to have, at a
// minimum, a length property which corresponds to integer-indexed
// properties.
// offset: Number?
// the location in obj to start iterating from. Defaults to 0.
// Optional.
// startWith: Array?
// An array to pack with the properties of obj. If provided,
// properties in obj are appended at the end of startWith and
// startWith is the returned array.
}
=====*/
/*=====
dojo.replace = function(tmpl, map, pattern){
// summary:
// Performs parameterized substitutions on a string. Throws an
// exception if any parameter is unmatched.
// tmpl: String
// String to be used as a template.
// map: Object|Function
// If an object, it is used as a dictionary to look up substitutions.
// If a function, it is called for every substitution with following
// parameters: a whole match, a name, an offset, and the whole template
// string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace
// for more details).
// pattern: RegEx?
// Optional regular expression objects that overrides the default pattern.
// Must be global and match one item. The default is: /\{([^\}]+)\}/g,
// which matches patterns like that: "{xxx}", where "xxx" is any sequence
// of characters, which doesn't include "}".
// returns: String
// Returns the substituted string.
// example:
// | // uses a dictionary for substitutions:
// | dojo.replace("Hello, {name.first} {name.last} AKA {nick}!",
// | {
// | nick: "Bob",
// | name: {
// | first: "Robert",
// | middle: "X",
// | last: "Cringely"
// | }
// | });
// | // returns: Hello, Robert Cringely AKA Bob!
// example:
// | // uses an array for substitutions:
// | dojo.replace("Hello, {0} {2}!",
// | ["Robert", "X", "Cringely"]);
// | // returns: Hello, Robert Cringely!
// example:
// | // uses a function for substitutions:
// | function sum(a){
// | var t = 0;
// | dojo.forEach(a, function(x){ t += x; });
// | return t;
// | }
// | dojo.replace(
// | "{count} payments averaging {avg} USD per payment.",
// | dojo.hitch(
// | { payments: [11, 16, 12] },
// | function(_, key){
// | switch(key){
// | case "count": return this.payments.length;
// | case "min": return Math.min.apply(Math, this.payments);
// | case "max": return Math.max.apply(Math, this.payments);
// | case "sum": return sum(this.payments);
// | case "avg": return sum(this.payments) / this.payments.length;
// | }
// | }
// | )
// | );
// | // prints: 3 payments averaging 13 USD per payment.
// example:
// | // uses an alternative PHP-like pattern for substitutions:
// | dojo.replace("Hello, ${0} ${2}!",
// | ["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
// | // returns: Hello, Robert Cringely!
return ""; // String
}
=====*/
});

718
lib/dojo/_base/loader.js.uncompressed.js
View File

@@ -1,718 +0,0 @@
define("dojo/_base/loader", ["./kernel", "../has", "require", "module", "./json", "./lang", "./array"], function(dojo, has, require, thisModule, json, lang, array) {
// module:
// dojo/_base/lader
// summary:
// This module defines the v1.x synchronous loader API.
// signal the loader in sync mode...
//>>pure-amd
if (!1){
console.error("cannot load the Dojo v1.x loader with a foreign loader");
return 0;
}
var makeErrorToken = function(id){
return {src:thisModule.id, id:id};
},
slashName = function(name){
return name.replace(/\./g, "/");
},
buildDetectRe = /\/\/>>built/,
dojoRequireCallbacks = [],
dojoRequireModuleStack = [],
dojoRequirePlugin = function(mid, require, loaded){
dojoRequireCallbacks.push(loaded);
array.forEach(mid.split(","), function(mid){
var module = getModule(mid, require.module);
dojoRequireModuleStack.push(module);
injectModule(module);
});
checkDojoRequirePlugin();
},
// checkDojoRequirePlugin inspects all of the modules demanded by a dojo/require!<module-list> dependency
// to see if they have arrived. The loader does not release *any* of these modules to be instantiated
// until *all* of these modules are on board, thereby preventing the evaluation of a module with dojo.require's
// that reference modules that are not available.
//
// The algorithm works by traversing the dependency graphs (remember, there can be cycles so they are not trees)
// of each module in the dojoRequireModuleStack array (which contains the list of modules demanded by dojo/require!).
// The moment a single module is discovered that is missing, the algorithm gives up and indicates that not all
// modules are on board. dojo/loadInit! and dojo/require! are ignored because there dependencies are inserted
// directly in dojoRequireModuleStack. For example, if "your/module" module depends on "dojo/require!my/module", then
// *both* "dojo/require!my/module" and "my/module" will be in dojoRequireModuleStack. Obviously, if "my/module"
// is on board, then "dojo/require!my/module" is also satisfied, so the algorithm doesn't check for "dojo/require!my/module".
//
// Note: inserting a dojo/require!<some-module-list> dependency in the dojoRequireModuleStack achieves nothing
// with the current algorithm; however, having such modules present makes it possible to optimize the algorithm
//
// Note: prior versions of this algorithm had an optimization that signaled loaded on dojo/require! dependencies
// individually (rather than waiting for them all to be resolved). The implementation proved problematic with cycles
// and plugins. However, it is possible to reattach that strategy in the future.
// a set from module-id to {undefined | 1 | 0}, where...
// undefined => the module has not been inspected
// 0 => the module or at least one of its dependencies has not arrived
// 1 => the module is a loadInit! or require! plugin resource, or is currently being traversed (therefore, assume
// OK until proven otherwise), or has been completely traversed and all dependencies have arrived
touched,
traverse = function(m){
touched[m.mid] = 1;
for(var t, module, deps = m.deps || [], i= 0; i<deps.length; i++){
module = deps[i];
if(!(t = touched[module.mid])){
if(t===0 || !traverse(module)){
touched[m.mid] = 0;
return false;
}
}
}
return true;
},
checkDojoRequirePlugin = function(){
// initialize the touched hash with easy-to-compute values that help short circuit recursive algorithm;
// recall loadInit/require plugin modules are dependencies of modules in dojoRequireModuleStack...
// which would cause a circular dependency chain that would never be resolved if checked here
// notice all dependencies of any particular loadInit/require plugin module will already
// be checked since those are pushed into dojoRequireModuleStack explicitly by the
// plugin...so if a particular loadInitPlugin module's dependencies are not really
// on board, that *will* be detected elsewhere in the traversal.
var module, mid;
touched = {};
for(mid in modules){
module = modules[mid];
// this could be improved by remembering the result of the regex tests
if(module.executed || module.noReqPluginCheck){
touched[mid] = 1;
}else{
if(module.noReqPluginCheck!==0){
// tag the module as either a loadInit or require plugin or not for future reference
module.noReqPluginCheck = /loadInit\!/.test(mid) || /require\!/.test(mid) ? 1 : 0;
}
if(module.noReqPluginCheck){
touched[mid] = 1;
}else if(module.injected!==arrived){
// not executed, has not arrived, and is not a loadInit or require plugin resource
touched[mid] = 0;
}// else, leave undefined and we'll traverse the dependencies
}
}
for(var t, i = 0, end = dojoRequireModuleStack.length; i<end; i++){
module = dojoRequireModuleStack[i];
if(!(t = touched[module.mid])){
if(t===0 || !traverse(module)){
return;
}
}
}
loaderVars.holdIdle();
var oldCallbacks = dojoRequireCallbacks;
dojoRequireCallbacks = [];
array.forEach(oldCallbacks, function(cb){cb(1);});
loaderVars.releaseIdle();
},
dojoLoadInitPlugin = function(mid, require, loaded){
// mid names a module that defines a "dojo load init" bundle, an object with two properties:
//
// * names: a vector of module ids that give top-level names to define in the lexical scope of def
// * def: a function that contains some some legacy loader API applications
//
// The point of def is to possibly cause some modules to be loaded (but not executed) by dojo/require! where the module
// ids are possibly-determined at runtime. For example, here is dojox.gfx from v1.6 expressed as an AMD module using the dojo/loadInit
// and dojo/require plugins.
//
// // dojox/gfx:
//
// define("*loadInit_12, {
// names:["dojo", "dijit", "dojox"],
// def: function(){
// dojo.loadInit(function(){
// var gfx = lang.getObject("dojox.gfx", true);
//
// //
// // code required to set gfx properties ommitted...
// //
//
// // now use the calculations to include the runtime-dependent module
// dojo.require("dojox.gfx." + gfx.renderer);
// });
// }
// });
//
// define(["dojo", "dojo/loadInit!" + id].concat("dojo/require!dojox/gfx/matric,dojox/gfx/_base"), function(dojo){
// // when this AMD factory function is executed, the following modules are guaranteed downloaded but not executed:
// // "dojox.gfx." + gfx.renderer
// // dojox.gfx.matrix
// // dojox.gfx._base
// dojo.provide("dojo.gfx");
// dojo.require("dojox.gfx.matrix");
// dojo.require("dojox.gfx._base");
// dojo.require("dojox.gfx." + gfx.renderer);
// return lang.getObject("dojo.gfx");
// });
// })();
//
// The idea is to run the legacy loader API with global variables shadowed, which allows these variables to
// be relocated. For example, dojox and dojo could be relocated to different names by giving a packageMap and the code above will
// execute properly (because the plugin below resolves the load init bundle.names module with respect to the module that demanded
// the plugin resource).
//
// Note that the relocation is specified in the runtime configuration; relocated names need not be set at build-time.
//
// Warning: this is not the best way to express dojox.gfx as and AMD module. In fact, the module has been properly converted in
// v1.7. However, this technique allows the builder to convert legacy modules into AMD modules and guarantee the codepath is the
// same in the converted AMD module.
require([mid], function(bundle){
// notice how names is resolved with respect to the module that demanded the plugin resource
require(bundle.names, function(){
// bring the bundle names into scope
for(var scopeText = "", args= [], i = 0; i<arguments.length; i++){
scopeText+= "var " + bundle.names[i] + "= arguments[" + i + "]; ";
args.push(arguments[i]);
}
eval(scopeText);
var callingModule = require.module,
deps = [],
hold = {},
requireList = [],
p,
syncLoaderApi = {
provide:function(moduleName){
// mark modules that arrive consequent to multiple provides in this module as arrived since they can't be injected
moduleName = slashName(moduleName);
var providedModule = getModule(moduleName, callingModule);
if(providedModule!==callingModule){
setArrived(providedModule);
}
},
require:function(moduleName, omitModuleCheck){
moduleName = slashName(moduleName);
omitModuleCheck && (getModule(moduleName, callingModule).result = nonmodule);
requireList.push(moduleName);
},
requireLocalization:function(moduleName, bundleName, locale){
// since we're going to need dojo/i8n, add it to deps if not already there
deps.length || (deps = ["dojo/i18n"]);
// figure out if the bundle is xdomain; if so, add it to the depsSet
locale = (locale || dojo.locale).toLowerCase();
moduleName = slashName(moduleName) + "/nls/" + (/root/i.test(locale) ? "" : locale + "/") + slashName(bundleName);
if(getModule(moduleName, callingModule).isXd){
deps.push("dojo/i18n!" + moduleName);
}// else the bundle will be loaded synchronously when the module is evaluated
},
loadInit:function(f){
f();
}
};
// hijack the correct dojo and apply bundle.def
try{
for(p in syncLoaderApi){
hold[p] = dojo[p];
dojo[p] = syncLoaderApi[p];
}
bundle.def.apply(null, args);
}catch(e){
signal("error", [makeErrorToken("failedDojoLoadInit"), e]);
}finally{
for(p in syncLoaderApi){
dojo[p] = hold[p];
}
}
// requireList is the list of modules that need to be downloaded but not executed before the callingModule can be executed
requireList.length && deps.push("dojo/require!" + requireList.join(","));
dojoRequireCallbacks.push(loaded);
array.forEach(requireList, function(mid){
var module = getModule(mid, require.module);
dojoRequireModuleStack.push(module);
injectModule(module);
});
checkDojoRequirePlugin();
});
});
},
extractApplication = function(
text, // the text to search
startSearch, // the position in text to start looking for the closing paren
startApplication // the position in text where the function application expression starts
){
// find end of the call by finding the matching end paren
// Warning: as usual, this will fail in the presense of unmatched right parans contained in strings, regexs, or unremoved comments
var parenRe = /\(|\)/g,
matchCount = 1,
match;
parenRe.lastIndex = startSearch;
while((match = parenRe.exec(text))){
if(match[0] == ")"){
matchCount -= 1;
}else{
matchCount += 1;
}
if(matchCount == 0){
break;
}
}
if(matchCount != 0){
throw "unmatched paren around character " + parenRe.lastIndex + " in: " + text;
}
//Put the master matching string in the results.
return [dojo.trim(text.substring(startApplication, parenRe.lastIndex))+";\n", parenRe.lastIndex];
},
// the following regex is taken from 1.6. It is a very poor technique to remove comments and
// will fail in some cases; for example, consider the code...
//
// var message = "Category-1 */* Category-2";
//
// The regex that follows will see a /* comment and trash the code accordingly. In fact, there are all
// kinds of cases like this with strings and regexs that will cause this design to fail miserably.
//
// Alternative regex designs exist that will result in less-likely failures, but will still fail in many cases.
// The only solution guaranteed 100% correct is to parse the code and that seems overkill for this
// backcompat/unbuilt-xdomain layer. In the end, since it's been this way for a while, we won't change it.
// See the opening paragraphs of Chapter 7 or ECME-262 which describes the lexical abiguity further.
removeCommentRe = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,
syncLoaderApiRe = /(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg,
amdLoaderApiRe = /(^|\s)(require|define)\s*\(/m,
extractLegacyApiApplications = function(text, noCommentText){
// scan the noCommentText for any legacy loader API applications. Copy such applications into result (this is
// used by the builder). Move dojo.loadInit applications to loadInitApplications string. Copy all other applications
// to otherApplications string. If no applications were found, return 0, signalling an AMD module. Otherwise, return
// loadInitApplications + otherApplications. Fixup text by replacing
//
// dojo.loadInit(// etc...
//
// with
//
// \n 0 && dojo.loadInit(// etc...
//
// Which results in the dojo.loadInit from *not* being applied. This design goes a long way towards protecting the
// code from an over-agressive removeCommentRe. However...
//
// WARNING: the removeCommentRe will cause an error if a detected comment removes all or part of a legacy-loader application
// that is not in a comment.
var match, startSearch, startApplication, application,
loadInitApplications = [],
otherApplications = [],
allApplications = [];
// noCommentText may be provided by a build app with comments extracted by a better method than regex (hopefully)
noCommentText = noCommentText || text.replace(removeCommentRe, function(match){
// remove iff the detected comment has text that looks like a sync loader API application; this helps by
// removing as little as possible, minimizing the changes the janky regex will kill the module
syncLoaderApiRe.lastIndex = amdLoaderApiRe.lastIndex = 0;
return (syncLoaderApiRe.test(match) || amdLoaderApiRe.test(match)) ? "" : match;
});
// find and extract all dojo.loadInit applications
while((match = syncLoaderApiRe.exec(noCommentText))){
startSearch = syncLoaderApiRe.lastIndex;
startApplication = startSearch - match[0].length;
application = extractApplication(noCommentText, startSearch, startApplication);
if(match[2]=="loadInit"){
loadInitApplications.push(application[0]);
}else{
otherApplications.push(application[0]);
}
syncLoaderApiRe.lastIndex = application[1];
}
allApplications = loadInitApplications.concat(otherApplications);
if(allApplications.length || !amdLoaderApiRe.test(noCommentText)){
// either there were some legacy loader API applications or there were no AMD API applications
return [text.replace(/(^|\s)dojo\.loadInit\s*\(/g, "\n0 && dojo.loadInit("), allApplications.join(""), allApplications];
}else{
// legacy loader API *was not* detected and AMD API *was* detected; therefore, assume it's an AMD module
return 0;
}
},
transformToAmd = function(module, text){
// This is roughly the equivalent of dojo._xdCreateResource in 1.6-; however, it expresses a v1.6- dojo
// module in terms of AMD define instead of creating the dojo proprietary xdomain module expression.
// The module could have originated from several sources:
//
// * amd require() a module, e.g., require(["my/module"])
// * amd require() a nonmodule, e.g., require(["my/resource.js"')
// * amd define() deps vector (always a module)
// * dojo.require() a module, e.g. dojo.require("my.module")
// * dojo.require() a nonmodule, e.g., dojo.require("my.module", true)
// * dojo.requireIf/requireAfterIf/platformRequire a module
//
// The module is scanned for legacy loader API applications; if none are found, then assume the module is an
// AMD module and return 0. Otherwise, a synthetic dojo/loadInit plugin resource is created and the module text
// is rewritten as an AMD module with the single dependency of this synthetic resource. When the dojo/loadInit
// plugin loaded the synthetic resource, it will cause all dojo.loadInit's to be executed, find all dojo.require's
// (either directly consequent to dojo.require or indirectly consequent to dojo.require[After]If or
// dojo.platformRequire, and finally cause loading of all dojo.required modules with the dojo/require plugin. Thus,
// when the dojo/loadInit plugin reports it has been loaded, all modules required by the given module are guaranteed
// loaded (but not executed). This then allows the module to execute it's code path without interupts, thereby
// following the synchronous code path.
var extractResult, id, names = [], namesAsStrings = [];
if(buildDetectRe.test(text) || !(extractResult = extractLegacyApiApplications(text))){
// buildDetectRe.test(text) => a built module, always AMD
// extractResult==0 => no sync API
return 0;
}
// manufacture a synthetic module id that can never be a real mdule id (just like require does)
id = module.mid + "-*loadInit";
// construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name
// the dojo/loadInit plugin assumes the first name in names is "dojo"
for(var p in getModule("dojo", module).result.scopeMap){
names.push(p);
namesAsStrings.push('"' + p + '"');
}
// rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource
return "// xdomain rewrite of " + module.path + "\n" +
"define('" + id + "',{\n" +
"\tnames:" + dojo.toJson(names) + ",\n" +
"\tdef:function(" + names.join(",") + "){" + extractResult[1] + "}" +
"});\n\n" +
"define(" + dojo.toJson(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});";
},
loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd),
sync =
loaderVars.sync,
xd =
loaderVars.xd,
arrived =
loaderVars.arrived,
nonmodule =
loaderVars.nonmodule,
executing =
loaderVars.executing,
executed =
loaderVars.executed,
syncExecStack =
loaderVars.syncExecStack,
modules =
loaderVars.modules,
execQ =
loaderVars.execQ,
getModule =
loaderVars.getModule,
injectModule =
loaderVars.injectModule,
setArrived =
loaderVars.setArrived,
signal =
loaderVars.signal,
finishExec =
loaderVars.finishExec,
execModule =
loaderVars.execModule,
getLegacyMode =
loaderVars.getLegacyMode;
dojo.provide = function(mid){
var executingModule = syncExecStack[0],
module = lang.mixin(getModule(slashName(mid), require.module), {
executed:executing,
result:lang.getObject(mid, true)
});
setArrived(module);
if(executingModule){
(executingModule.provides || (executingModule.provides = [])).push(function(){
module.result = lang.getObject(mid);
delete module.provides;
module.executed!==executed && finishExec(module);
});
}// else dojo.provide called not consequent to loading; therefore, give up trying to publish module value to loader namespace
return module.result;
};
has.add("config-publishRequireResult", 1, 0, 0);
dojo.require = function(moduleName, omitModuleCheck) {
// summary:
// loads a Javascript module from the appropriate URI
//
// moduleName: String
// module name to load, using periods for separators,
// e.g. "dojo.date.locale". Module paths are de-referenced by dojo's
// internal mapping of locations to names and are disambiguated by
// longest prefix. See `dojo.registerModulePath()` for details on
// registering new modules.
//
// omitModuleCheck: Boolean?
// if `true`, omitModuleCheck skips the step of ensuring that the
// loaded file actually defines the symbol it is referenced by.
// For example if it called as `dojo.require("a.b.c")` and the
// file located at `a/b/c.js` does not define an object `a.b.c`,
// and exception will be throws whereas no exception is raised
// when called as `dojo.require("a.b.c", true)`
//
// description:
// Modules are loaded via dojo.require by using one of two loaders: the normal loader
// and the xdomain loader. The xdomain loader is used when dojo was built with a
// custom build that specified loader=xdomain and the module lives on a modulePath
// that is a whole URL, with protocol and a domain. The versions of Dojo that are on
// the Google and AOL CDNs use the xdomain loader.
//
// If the module is loaded via the xdomain loader, it is an asynchronous load, since
// the module is added via a dynamically created script tag. This
// means that dojo.require() can return before the module has loaded. However, this
// should only happen in the case where you do dojo.require calls in the top-level
// HTML page, or if you purposely avoid the loader checking for dojo.require
// dependencies in your module by using a syntax like dojo["require"] to load the module.
//
// Sometimes it is useful to not have the loader detect the dojo.require calls in the
// module so that you can dynamically load the modules as a result of an action on the
// page, instead of right at module load time.
//
// Also, for script blocks in an HTML page, the loader does not pre-process them, so
// it does not know to download the modules before the dojo.require calls occur.
//
// So, in those two cases, when you want on-the-fly module loading or for script blocks
// in the HTML page, special care must be taken if the dojo.required code is loaded
// asynchronously. To make sure you can execute code that depends on the dojo.required
// modules, be sure to add the code that depends on the modules in a dojo.addOnLoad()
// callback. dojo.addOnLoad waits for all outstanding modules to finish loading before
// executing.
//
// This type of syntax works with both xdomain and normal loaders, so it is good
// practice to always use this idiom for on-the-fly code loading and in HTML script
// blocks. If at some point you change loaders and where the code is loaded from,
// it will all still work.
//
// More on how dojo.require
// `dojo.require("A.B")` first checks to see if symbol A.B is
// defined. If it is, it is simply returned (nothing to do).
//
// If it is not defined, it will look for `A/B.js` in the script root
// directory.
//
// `dojo.require` throws an exception if it cannot find a file
// to load, or if the symbol `A.B` is not defined after loading.
//
// It returns the object `A.B`, but note the caveats above about on-the-fly loading and
// HTML script blocks when the xdomain loader is loading a module.
//
// `dojo.require()` does nothing about importing symbols into
// the current namespace. It is presumed that the caller will
// take care of that.
//
// example:
// To use dojo.require in conjunction with dojo.ready:
//
// | dojo.require("foo");
// | dojo.require("bar");
// | dojo.addOnLoad(function(){
// | //you can now safely do something with foo and bar
// | });
//
// example:
// For example, to import all symbols into a local block, you might write:
//
// | with (dojo.require("A.B")) {
// | ...
// | }
//
// And to import just the leaf symbol to a local variable:
//
// | var B = dojo.require("A.B");
// | ...
//
// returns:
// the required namespace object
function doRequire(mid, omitModuleCheck){
var module = getModule(slashName(mid), require.module);
if(syncExecStack.length && syncExecStack[0].finish){
// switched to async loading in the middle of evaluating a legacy module; stop
// applying dojo.require so the remaining dojo.requires are applied in order
syncExecStack[0].finish.push(mid);
return undefined;
}
// recall module.executed has values {0, executing, executed}; therefore, truthy indicates executing or executed
if(module.executed){
return module.result;
}
omitModuleCheck && (module.result = nonmodule);
var currentMode = getLegacyMode();
// recall, in sync mode to inject is to *eval* the module text
// if the module is a legacy module, this is the same as executing
// but if the module is an AMD module, this means defining, not executing
injectModule(module);
// the inject may have changed the mode
currentMode = getLegacyMode();
// in sync mode to dojo.require is to execute
if(module.executed!==executed && module.injected===arrived){
// the module was already here before injectModule was called probably finishing up a xdomain
// load, but maybe a module given to the loader directly rather than having the loader retrieve it
loaderVars.holdIdle();
execModule(module);
loaderVars.releaseIdle();
}
if(module.executed){
return module.result;
}
if(currentMode==sync){
// the only way to get here is in sync mode and dojo.required a module that
// * was loaded async in the injectModule application a few lines up
// * was an AMD module that had deps that are being loaded async and therefore couldn't execute
if(module.cjs){
// the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top
execQ.unshift(module);
}else{
// the module was a legacy module
syncExecStack.length && (syncExecStack[0].finish= [mid]);
}
}else{
// the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting
// the module value synchronously; make sure it gets executed though
execQ.push(module);
}
return undefined;
}
var result = doRequire(moduleName, omitModuleCheck);
if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){
lang.setObject(moduleName, result);
}
return result;
};
dojo.loadInit = function(f) {
f();
};
dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){
// summary:
// Maps a module name to a path
// description:
// An unregistered module is given the default path of ../[module],
// relative to Dojo root. For example, module acme is mapped to
// ../acme. If you want to use a different module name, use
// dojo.registerModulePath.
// example:
// If your dojo.js is located at this location in the web root:
// | /myapp/js/dojo/dojo/dojo.js
// and your modules are located at:
// | /myapp/js/foo/bar.js
// | /myapp/js/foo/baz.js
// | /myapp/js/foo/thud/xyzzy.js
// Your application can tell Dojo to locate the "foo" namespace by calling:
// | dojo.registerModulePath("foo", "../../foo");
// At which point you can then use dojo.require() to load the
// modules (assuming they provide() the same things which are
// required). The full code might be:
// | <script type="text/javascript"
// | src="/myapp/js/dojo/dojo/dojo.js"></script>
// | <script type="text/javascript">
// | dojo.registerModulePath("foo", "../../foo");
// | dojo.require("foo.bar");
// | dojo.require("foo.baz");
// | dojo.require("foo.thud.xyzzy");
// | </script>
var paths = {};
paths[moduleName.replace(/\./g, "/")] = prefix;
require({paths:paths});
};
dojo.platformRequire = function(/*Object*/modMap){
// summary:
// require one or more modules based on which host environment
// Dojo is currently operating in
// description:
// This method takes a "map" of arrays which one can use to
// optionally load dojo modules. The map is indexed by the
// possible dojo.name_ values, with two additional values:
// "default" and "common". The items in the "default" array will
// be loaded if none of the other items have been choosen based on
// dojo.name_, set by your host environment. The items in the
// "common" array will *always* be loaded, regardless of which
// list is chosen.
// example:
// | dojo.platformRequire({
// | browser: [
// | "foo.sample", // simple module
// | "foo.test",
// | ["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
// | ],
// | default: [ "foo.sample._base" ],
// | common: [ "important.module.common" ]
// | });
var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []),
temp;
while(result.length){
if(lang.isArray(temp = result.shift())){
dojo.require.apply(dojo, temp);
}else{
dojo.require(temp);
}
}
};
dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){
// summary:
// If the condition is true then call `dojo.require()` for the specified
// resource
//
// example:
// | dojo.requireIf(dojo.isBrowser, "my.special.Module");
if(condition){
dojo.require(moduleName, omitModuleCheck);
}
};
dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){
require(["../i18n"], function(i18n){
i18n.getLocalization(moduleName, bundleName, locale);
});
};
return {
extractLegacyApiApplications:extractLegacyApiApplications,
require:loaderVars.dojoRequirePlugin,
loadInit:dojoLoadInitPlugin
};
});

3
lib/dojo/_base/query.js.uncompressed.js
View File

@@ -1,3 +0,0 @@
define("dojo/_base/query", ["./kernel", "../query", "./NodeList"], function(dojo){
return dojo.query;
});

187
lib/dojo/_base/sniff.js.uncompressed.js
View File

@@ -1,187 +0,0 @@
define("dojo/_base/sniff", ["./kernel", "../has"], function(dojo, has){
// module:
// dojo/sniff
// summary:
// This module populates the dojo browser version sniffing properties.
if(!1){
return has;
}
dojo.isBrowser = true,
dojo._name = "browser";
var hasAdd = has.add,
n = navigator,
dua = n.userAgent,
dav = n.appVersion,
tv = parseFloat(dav),
isOpera,
isAIR,
isKhtml,
isWebKit,
isChrome,
isMac,
isSafari,
isMozilla ,
isMoz,
isIE,
isFF,
isQuirks,
isIos,
isAndroid,
isWii;
/*=====
dojo.isBrowser = {
// example:
// | if(dojo.isBrowser){ ... }
};
dojo.isFF = {
// example:
// | if(dojo.isFF > 1){ ... }
};
dojo.isIE = {
// example:
// | if(dojo.isIE > 6){
// | // we are IE7
// | }
};
dojo.isSafari = {
// example:
// | if(dojo.isSafari){ ... }
// example:
// Detect iPhone:
// | if(dojo.isSafari && navigator.userAgent.indexOf("iPhone") != -1){
// | // we are iPhone. Note, iPod touch reports "iPod" above and fails this test.
// | }
};
dojo.mixin(dojo, {
// isBrowser: Boolean
// True if the client is a web-browser
isBrowser: true,
// isFF: Number | undefined
// Version as a Number if client is FireFox. undefined otherwise. Corresponds to
// major detected FireFox version (1.5, 2, 3, etc.)
isFF: 2,
// isIE: Number | undefined
// Version as a Number if client is MSIE(PC). undefined otherwise. Corresponds to
// major detected IE version (6, 7, 8, etc.)
isIE: 6,
// isKhtml: Number | undefined
// Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major
// detected version.
isKhtml: 0,
// isWebKit: Number | undefined
// Version as a Number if client is a WebKit-derived browser (Konqueror,
// Safari, Chrome, etc.). undefined otherwise.
isWebKit: 0,
// isMozilla: Number | undefined
// Version as a Number if client is a Mozilla-based browser (Firefox,
// SeaMonkey). undefined otherwise. Corresponds to major detected version.
isMozilla: 0,
// isOpera: Number | undefined
// Version as a Number if client is Opera. undefined otherwise. Corresponds to
// major detected version.
isOpera: 0,
// isSafari: Number | undefined
// Version as a Number if client is Safari or iPhone. undefined otherwise.
isSafari: 0,
// isChrome: Number | undefined
// Version as a Number if client is Chrome browser. undefined otherwise.
isChrome: 0,
// isMac: Boolean
// True if the client runs on Mac
isMac: 0,
// isIos: Boolean
// True if client is iPhone, iPod, or iPad
isIos: 0,
// isAndroid: Number | undefined
// Version as a Number if client is android browser. undefined otherwise.
isAndroid: 0,
// isWii: Boolean
// True if client is Wii
isWii: 0
});
=====*/
// fill in the rendering support information in dojo.render.*
if(dua.indexOf("AdobeAIR") >= 0){ isAIR = 1; }
isKhtml = (dav.indexOf("Konqueror") >= 0) ? tv : 0;
isWebKit = parseFloat(dua.split("WebKit/")[1]) || undefined;
isChrome = parseFloat(dua.split("Chrome/")[1]) || undefined;
isMac = dav.indexOf("Macintosh") >= 0;
isIos = /iPhone|iPod|iPad/.test(dua);
isAndroid = parseFloat(dua.split("Android ")[1]) || undefined;
isWii = typeof opera != "undefined" && opera.wiiremote;
// safari detection derived from:
// http://developer.apple.com/internet/safari/faq.html#anchor2
// http://developer.apple.com/internet/safari/uamatrix.html
var index = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0);
if(index && !isChrome){
// try to grab the explicit Safari version first. If we don't get
// one, look for less than 419.3 as the indication that we're on something
// "Safari 2-ish".
isSafari = parseFloat(dav.split("Version/")[1]);
if(!isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){
isSafari = 2;
}
}
if (!has("dojo-webkit")) {
if(dua.indexOf("Opera") >= 0){
isOpera = tv;
// see http://dev.opera.com/articles/view/opera-ua-string-changes and http://www.useragentstring.com/pages/Opera/
// 9.8 has both styles; <9.8, 9.9 only old style
if(isOpera >= 9.8){
isOpera = parseFloat(dua.split("Version/")[1]) || tv;
}
}
if(dua.indexOf("Gecko") >= 0 && !isKhtml && !isWebKit){
isMozilla = isMoz = tv;
}
if(isMoz){
//We really need to get away from this. Consider a sane isGecko approach for the future.
isFF = parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined;
}
if(document.all && !isOpera){
isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
//In cases where the page has an HTTP header or META tag with
//X-UA-Compatible, then it is in emulation mode.
//Make sure isIE reflects the desired version.
//document.documentMode of 5 means quirks mode.
//Only switch the value if documentMode's major version
//is different from isIE's major version.
var mode = document.documentMode;
if(mode && mode != 5 && Math.floor(isIE) != mode){
isIE = mode;
}
}
}
isQuirks = document.compatMode == "BackCompat";
hasAdd("opera", dojo.isOpera = isOpera);
hasAdd("air", dojo.isAIR = isAIR);
hasAdd("khtml", dojo.isKhtml = isKhtml);
hasAdd("webkit", dojo.isWebKit = isWebKit);
hasAdd("chrome", dojo.isChrome = isChrome);
hasAdd("mac", dojo.isMac = isMac );
hasAdd("safari", dojo.isSafari = isSafari);
hasAdd("mozilla", dojo.isMozilla = dojo.isMoz = isMozilla );
hasAdd("ie", dojo.isIE = isIE );
hasAdd("ff", dojo.isFF = isFF);
hasAdd("quirks", dojo.isQuirks = isQuirks);
hasAdd("ios", dojo.isIos = isIos);
hasAdd("android", dojo.isAndroid = isAndroid);
dojo.locale = dojo.locale || (isIE ? n.userLanguage : n.language).toLowerCase();
return has;
});

81
lib/dojo/_base/unload.js.uncompressed.js
View File

@@ -1,81 +0,0 @@
define("dojo/_base/unload", ["./kernel", "./connect"], function(dojo, connect) {
// module:
// dojo/unload
// summary:
// This module contains the document and window unload detection API.
var win = window;
/*=====
dojo.windowUnloaded = function(){
// summary:
// signal fired by impending window destruction. You may use
// dojo.addOnWindowUnload() to register a listener for this
// event. NOTE: if you wish to dojo.connect() to this method
// to perform page/application cleanup, be aware that this
// event WILL NOT fire if no handler has been registered with
// dojo.addOnWindowUnload. This behavior started in Dojo 1.3.
// Previous versions always triggered dojo.windowUnloaded. See
// dojo.addOnWindowUnload for more info.
};
=====*/
dojo.addOnWindowUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){
// summary:
// registers a function to be triggered when window.onunload
// fires.
// description:
// The first time that addOnWindowUnload is called Dojo
// will register a page listener to trigger your unload
// handler with. Note that registering these handlers may
// destory "fastback" page caching in browsers that support
// it. Be careful trying to modify the DOM or access
// JavaScript properties during this phase of page unloading:
// they may not always be available. Consider
// dojo.addOnUnload() if you need to modify the DOM or do
// heavy JavaScript work since it fires at the eqivalent of
// the page's "onbeforeunload" event.
// example:
// | dojo.addOnWindowUnload(functionPointer)
// | dojo.addOnWindowUnload(object, "functionName");
// | dojo.addOnWindowUnload(object, function(){ /* ... */});
if (!dojo.windowUnloaded) {
connect.connect(win, "unload", (dojo.windowUnloaded= function(){}));
}
connect.connect(win, "unload", obj, functionName);
};
dojo.addOnUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){
// summary:
// registers a function to be triggered when the page unloads.
// description:
// The first time that addOnUnload is called Dojo will
// register a page listener to trigger your unload handler
// with.
//
// In a browser enviroment, the functions will be triggered
// during the window.onbeforeunload event. Be careful of doing
// too much work in an unload handler. onbeforeunload can be
// triggered if a link to download a file is clicked, or if
// the link is a javascript: link. In these cases, the
// onbeforeunload event fires, but the document is not
// actually destroyed. So be careful about doing destructive
// operations in a dojo.addOnUnload callback.
//
// Further note that calling dojo.addOnUnload will prevent
// browsers from using a "fast back" cache to make page
// loading via back button instantaneous.
// example:
// | dojo.addOnUnload(functionPointer)
// | dojo.addOnUnload(object, "functionName")
// | dojo.addOnUnload(object, function(){ /* ... */});
connect.connect(win, "beforeunload", obj, functionName);
};
return {
addOnWindowUnload: dojo.addOnWindowUnload,
addOnUnload: dojo.addOnUnload
};
});

111
lib/dojo/_base/url.js.uncompressed.js
View File

@@ -1,111 +0,0 @@
define("dojo/_base/url", ["./kernel"], function(dojo) {
// module:
// dojo/url
// summary:
// This module contains dojo._Url
var
ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"),
ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"),
_Url = function(){
var n = null,
_a = arguments,
uri = [_a[0]];
// resolve uri components relative to each other
for(var i = 1; i<_a.length; i++){
if(!_a[i]){ continue; }
// Safari doesn't support this.constructor so we have to be explicit
// FIXME: Tracked (and fixed) in Webkit bug 3537.
// http://bugs.webkit.org/show_bug.cgi?id=3537
var relobj = new _Url(_a[i]+""),
uriobj = new _Url(uri[0]+"");
if(
relobj.path == "" &&
!relobj.scheme &&
!relobj.authority &&
!relobj.query
){
if(relobj.fragment != n){
uriobj.fragment = relobj.fragment;
}
relobj = uriobj;
}else if(!relobj.scheme){
relobj.scheme = uriobj.scheme;
if(!relobj.authority){
relobj.authority = uriobj.authority;
if(relobj.path.charAt(0) != "/"){
var path = uriobj.path.substring(0,
uriobj.path.lastIndexOf("/") + 1) + relobj.path;
var segs = path.split("/");
for(var j = 0; j < segs.length; j++){
if(segs[j] == "."){
// flatten "./" references
if(j == segs.length - 1){
segs[j] = "";
}else{
segs.splice(j, 1);
j--;
}
}else if(j > 0 && !(j == 1 && segs[0] == "") &&
segs[j] == ".." && segs[j-1] != ".."){
// flatten "../" references
if(j == (segs.length - 1)){
segs.splice(j, 1);
segs[j - 1] = "";
}else{
segs.splice(j - 1, 2);
j -= 2;
}
}
}
relobj.path = segs.join("/");
}
}
}
uri = [];
if(relobj.scheme){
uri.push(relobj.scheme, ":");
}
if(relobj.authority){
uri.push("//", relobj.authority);
}
uri.push(relobj.path);
if(relobj.query){
uri.push("?", relobj.query);
}
if(relobj.fragment){
uri.push("#", relobj.fragment);
}
}
this.uri = uri.join("");
// break the uri into its main components
var r = this.uri.match(ore);
this.scheme = r[2] || (r[1] ? "" : n);
this.authority = r[4] || (r[3] ? "" : n);
this.path = r[5]; // can never be undefined
this.query = r[7] || (r[6] ? "" : n);
this.fragment = r[9] || (r[8] ? "" : n);
if(this.authority != n){
// server based naming authority
r = this.authority.match(ire);
this.user = r[3] || n;
this.password = r[4] || n;
this.host = r[6] || r[7]; // ipv6 || ipv4
this.port = r[9] || n;
}
};
_Url.prototype.toString = function(){ return this.uri; };
return dojo._Url = _Url;
});

126
lib/dojo/_base/window.js.uncompressed.js
View File

@@ -1,126 +0,0 @@
define("dojo/_base/window", ["./kernel", "../has", "./sniff"], function(dojo, has){
// module:
// dojo/window
// summary:
// This module provides an API to save/set/restore the global/document scope.
/*=====
dojo.doc = {
// summary:
// Alias for the current document. 'dojo.doc' can be modified
// for temporary context shifting. Also see dojo.withDoc().
// description:
// Refer to dojo.doc rather
// than referring to 'window.document' to ensure your code runs
// correctly in managed contexts.
// example:
// | n.appendChild(dojo.doc.createElement('div'));
}
=====*/
dojo.doc = this["document"] || null;
dojo.body = function(){
// summary:
// Return the body element of the document
// return the body object associated with dojo.doc
// example:
// | dojo.body().appendChild(dojo.doc.createElement('div'));
// Note: document.body is not defined for a strict xhtml document
// Would like to memoize this, but dojo.doc can change vi dojo.withDoc().
return dojo.doc.body || dojo.doc.getElementsByTagName("body")[0]; // Node
};
dojo.setContext = function(/*Object*/globalObject, /*DocumentElement*/globalDocument){
// summary:
// changes the behavior of many core Dojo functions that deal with
// namespace and DOM lookup, changing them to work in a new global
// context (e.g., an iframe). The varibles dojo.global and dojo.doc
// are modified as a result of calling this function and the result of
// `dojo.body()` likewise differs.
dojo.global = ret.global = globalObject;
dojo.doc = ret.doc = globalDocument;
};
dojo.withGlobal = function( /*Object*/globalObject,
/*Function*/callback,
/*Object?*/thisObject,
/*Array?*/cbArguments){
// summary:
// Invoke callback with globalObject as dojo.global and
// globalObject.document as dojo.doc.
// description:
// Invoke callback with globalObject as dojo.global and
// globalObject.document as dojo.doc. If provided, globalObject
// will be executed in the context of object thisObject
// When callback() returns or throws an error, the dojo.global
// and dojo.doc will be restored to its previous state.
var oldGlob = dojo.global;
try{
dojo.global = ret.global = globalObject;
return dojo.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments);
}finally{
dojo.global = ret.global = oldGlob;
}
};
dojo.withDoc = function( /*DocumentElement*/documentObject,
/*Function*/callback,
/*Object?*/thisObject,
/*Array?*/cbArguments){
// summary:
// Invoke callback with documentObject as dojo.doc.
// description:
// Invoke callback with documentObject as dojo.doc. If provided,
// callback will be executed in the context of object thisObject
// When callback() returns or throws an error, the dojo.doc will
// be restored to its previous state.
var oldDoc = dojo.doc,
oldQ = dojo.isQuirks,
oldIE = dojo.isIE, isIE, mode, pwin;
try{
dojo.doc = ret.doc = documentObject;
// update dojo.isQuirks and the value of the has feature "quirks"
dojo.isQuirks = has.add("quirks", dojo.doc.compatMode == "BackCompat", true, true); // no need to check for QuirksMode which was Opera 7 only
if(has("ie")){
if((pwin = documentObject.parentWindow) && pwin.navigator){
// re-run IE detection logic and update dojo.isIE / has("ie")
// (the only time parentWindow/navigator wouldn't exist is if we were not
// passed an actual legitimate document object)
isIE = parseFloat(pwin.navigator.appVersion.split("MSIE ")[1]) || undefined;
mode = documentObject.documentMode;
if(mode && mode != 5 && Math.floor(isIE) != mode){
isIE = mode;
}
dojo.isIE = has.add("ie", isIE, true, true);
}
}
if(thisObject && typeof callback == "string"){
callback = thisObject[callback];
}
return callback.apply(thisObject, cbArguments || []);
}finally{
dojo.doc = ret.doc = oldDoc;
dojo.isQuirks = has.add("quirks", oldQ, true, true);
dojo.isIE = has.add("ie", oldIE, true, true);
}
};
var ret = {
global: dojo.global,
doc: dojo.doc,
body: dojo.body,
setContext: dojo.setContext,
withGlobal: dojo.withGlobal,
withDoc: dojo.withDoc
};
return ret;
});

830
lib/dojo/_base/xhr.js.uncompressed.js
View File

@@ -1,830 +0,0 @@
define("dojo/_base/xhr", [
"./kernel", "./sniff", "require", "../io-query", "../dom", "../dom-form", "./Deferred", "./json", "./lang", "./array", "../on"
], function(dojo, has, require, ioq, dom, domForm, deferred, json, lang, array, on){
// module:
// dojo/_base.xhr
// summary:
// This modules defines the dojo.xhr* API.
has.add("native-xhr", function() {
// if true, the environment has a native XHR implementation
return typeof XMLHttpRequest !== 'undefined';
});
if(1 && require.getXhr){
dojo._xhrObj = require.getXhr;
}else if (has("native-xhr")){
dojo._xhrObj = function(){
// summary:
// does the work of portably generating a new XMLHTTPRequest object.
try{
return new XMLHttpRequest();
}catch(e){
throw new Error("XMLHTTP not available: "+e);
}
};
}else{
// PROGIDs are in order of decreasing likelihood; this will change in time.
for(var XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'], progid, i = 0; i < 3;){
try{
progid = XMLHTTP_PROGIDS[i++];
if (new ActiveXObject(progid)) {
// this progid works; therefore, use it from now on
break;
}
}catch(e){
// squelch; we're just trying to find a good ActiveX PROGID
// if they all fail, then progid ends up as the last attempt and that will signal the error
// the first time the client actually tries to exec an xhr
}
}
dojo._xhrObj= function() {
return new ActiveXObject(progid);
};
}
var cfg = dojo.config;
// mix in io-query and dom-form
dojo.objectToQuery = ioq.objectToQuery;
dojo.queryToObject = ioq.queryToObject;
dojo.fieldToObject = domForm.fieldToObject;
dojo.formToObject = domForm.toObject;
dojo.formToQuery = domForm.toQuery;
dojo.formToJson = domForm.toJson;
// need to block async callbacks from snatching this thread as the result
// of an async callback might call another sync XHR, this hangs khtml forever
// must checked by watchInFlight()
dojo._blockAsync = false;
// MOW: remove dojo._contentHandlers alias in 2.0
var handlers = dojo._contentHandlers = dojo.contentHandlers = {
// summary:
// A map of availble XHR transport handle types. Name matches the
// `handleAs` attribute passed to XHR calls.
//
// description:
// A map of availble XHR transport handle types. Name matches the
// `handleAs` attribute passed to XHR calls. Each contentHandler is
// called, passing the xhr object for manipulation. The return value
// from the contentHandler will be passed to the `load` or `handle`
// functions defined in the original xhr call.
//
// example:
// Creating a custom content-handler:
// | dojo.contentHandlers.makeCaps = function(xhr){
// | return xhr.responseText.toUpperCase();
// | }
// | // and later:
// | dojo.xhrGet({
// | url:"foo.txt",
// | handleAs:"makeCaps",
// | load: function(data){ /* data is a toUpper version of foo.txt */ }
// | });
"text": function(xhr){
// summary: A contentHandler which simply returns the plaintext response data
return xhr.responseText;
},
"json": function(xhr){
// summary: A contentHandler which returns a JavaScript object created from the response data
return json.fromJson(xhr.responseText || null);
},
"json-comment-filtered": function(xhr){
// summary: A contentHandler which expects comment-filtered JSON.
// description:
// A contentHandler which expects comment-filtered JSON.
// the json-comment-filtered option was implemented to prevent
// "JavaScript Hijacking", but it is less secure than standard JSON. Use
// standard JSON instead. JSON prefixing can be used to subvert hijacking.
//
// Will throw a notice suggesting to use application/json mimetype, as
// json-commenting can introduce security issues. To decrease the chances of hijacking,
// use the standard `json` contentHandler, and prefix your "JSON" with: {}&&
//
// use djConfig.useCommentedJson = true to turn off the notice
if(!dojo.config.useCommentedJson){
console.warn("Consider using the standard mimetype:application/json."
+ " json-commenting can introduce security issues. To"
+ " decrease the chances of hijacking, use the standard the 'json' handler and"
+ " prefix your json with: {}&&\n"
+ "Use djConfig.useCommentedJson=true to turn off this message.");
}
var value = xhr.responseText;
var cStartIdx = value.indexOf("\/*");
var cEndIdx = value.lastIndexOf("*\/");
if(cStartIdx == -1 || cEndIdx == -1){
throw new Error("JSON was not comment filtered");
}
return json.fromJson(value.substring(cStartIdx+2, cEndIdx));
},
"javascript": function(xhr){
// summary: A contentHandler which evaluates the response data, expecting it to be valid JavaScript
// FIXME: try Moz and IE specific eval variants?
return dojo.eval(xhr.responseText);
},
"xml": function(xhr){
// summary: A contentHandler returning an XML Document parsed from the response data
var result = xhr.responseXML;
if(has("ie")){
if((!result || !result.documentElement)){
//WARNING: this branch used by the xml handling in dojo.io.iframe,
//so be sure to test dojo.io.iframe if making changes below.
var ms = function(n){ return "MSXML" + n + ".DOMDocument"; };
var dp = ["Microsoft.XMLDOM", ms(6), ms(4), ms(3), ms(2)];
array.some(dp, function(p){
try{
var dom = new ActiveXObject(p);
dom.async = false;
dom.loadXML(xhr.responseText);
result = dom;
}catch(e){ return false; }
return true;
});
}
}
return result; // DOMDocument
},
"json-comment-optional": function(xhr){
// summary: A contentHandler which checks the presence of comment-filtered JSON and
// alternates between the `json` and `json-comment-filtered` contentHandlers.
if(xhr.responseText && /^[^{\[]*\/\*/.test(xhr.responseText)){
return handlers["json-comment-filtered"](xhr);
}else{
return handlers["json"](xhr);
}
}
};
/*=====
dojo.__IoArgs = function(){
// url: String
// URL to server endpoint.
// content: Object?
// Contains properties with string values. These
// properties will be serialized as name1=value2 and
// passed in the request.
// timeout: Integer?
// Milliseconds to wait for the response. If this time
// passes, the then error callbacks are called.
// form: DOMNode?
// DOM node for a form. Used to extract the form values
// and send to the server.
// preventCache: Boolean?
// Default is false. If true, then a
// "dojo.preventCache" parameter is sent in the request
// with a value that changes with each request
// (timestamp). Useful only with GET-type requests.
// handleAs: String?
// Acceptable values depend on the type of IO
// transport (see specific IO calls for more information).
// rawBody: String?
// Sets the raw body for an HTTP request. If this is used, then the content
// property is ignored. This is mostly useful for HTTP methods that have
// a body to their requests, like PUT or POST. This property can be used instead
// of postData and putData for dojo.rawXhrPost and dojo.rawXhrPut respectively.
// ioPublish: Boolean?
// Set this explicitly to false to prevent publishing of topics related to
// IO operations. Otherwise, if djConfig.ioPublish is set to true, topics
// will be published via dojo.publish for different phases of an IO operation.
// See dojo.__IoPublish for a list of topics that are published.
// load: Function?
// This function will be
// called on a successful HTTP response code.
// error: Function?
// This function will
// be called when the request fails due to a network or server error, the url
// is invalid, etc. It will also be called if the load or handle callback throws an
// exception, unless djConfig.debugAtAllCosts is true. This allows deployed applications
// to continue to run even when a logic error happens in the callback, while making
// it easier to troubleshoot while in debug mode.
// handle: Function?
// This function will
// be called at the end of every request, whether or not an error occurs.
this.url = url;
this.content = content;
this.timeout = timeout;
this.form = form;
this.preventCache = preventCache;
this.handleAs = handleAs;
this.ioPublish = ioPublish;
this.load = function(response, ioArgs){
// ioArgs: dojo.__IoCallbackArgs
// Provides additional information about the request.
// response: Object
// The response in the format as defined with handleAs.
}
this.error = function(response, ioArgs){
// ioArgs: dojo.__IoCallbackArgs
// Provides additional information about the request.
// response: Object
// The response in the format as defined with handleAs.
}
this.handle = function(loadOrError, response, ioArgs){
// loadOrError: String
// Provides a string that tells you whether this function
// was called because of success (load) or failure (error).
// response: Object
// The response in the format as defined with handleAs.
// ioArgs: dojo.__IoCallbackArgs
// Provides additional information about the request.
}
}
=====*/
/*=====
dojo.__IoCallbackArgs = function(args, xhr, url, query, handleAs, id, canDelete, json){
// args: Object
// the original object argument to the IO call.
// xhr: XMLHttpRequest
// For XMLHttpRequest calls only, the
// XMLHttpRequest object that was used for the
// request.
// url: String
// The final URL used for the call. Many times it
// will be different than the original args.url
// value.
// query: String
// For non-GET requests, the
// name1=value1&name2=value2 parameters sent up in
// the request.
// handleAs: String
// The final indicator on how the response will be
// handled.
// id: String
// For dojo.io.script calls only, the internal
// script ID used for the request.
// canDelete: Boolean
// For dojo.io.script calls only, indicates
// whether the script tag that represents the
// request can be deleted after callbacks have
// been called. Used internally to know when
// cleanup can happen on JSONP-type requests.
// json: Object
// For dojo.io.script calls only: holds the JSON
// response for JSONP-type requests. Used
// internally to hold on to the JSON responses.
// You should not need to access it directly --
// the same object should be passed to the success
// callbacks directly.
this.args = args;
this.xhr = xhr;
this.url = url;
this.query = query;
this.handleAs = handleAs;
this.id = id;
this.canDelete = canDelete;
this.json = json;
}
=====*/
/*=====
dojo.__IoPublish = function(){
// summary:
// This is a list of IO topics that can be published
// if djConfig.ioPublish is set to true. IO topics can be
// published for any Input/Output, network operation. So,
// dojo.xhr, dojo.io.script and dojo.io.iframe can all
// trigger these topics to be published.
// start: String
// "/dojo/io/start" is sent when there are no outstanding IO
// requests, and a new IO request is started. No arguments
// are passed with this topic.
// send: String
// "/dojo/io/send" is sent whenever a new IO request is started.
// It passes the dojo.Deferred for the request with the topic.
// load: String
// "/dojo/io/load" is sent whenever an IO request has loaded
// successfully. It passes the response and the dojo.Deferred
// for the request with the topic.
// error: String
// "/dojo/io/error" is sent whenever an IO request has errored.
// It passes the error and the dojo.Deferred
// for the request with the topic.
// done: String
// "/dojo/io/done" is sent whenever an IO request has completed,
// either by loading or by erroring. It passes the error and
// the dojo.Deferred for the request with the topic.
// stop: String
// "/dojo/io/stop" is sent when all outstanding IO requests have
// finished. No arguments are passed with this topic.
this.start = "/dojo/io/start";
this.send = "/dojo/io/send";
this.load = "/dojo/io/load";
this.error = "/dojo/io/error";
this.done = "/dojo/io/done";
this.stop = "/dojo/io/stop";
}
=====*/
dojo._ioSetArgs = function(/*dojo.__IoArgs*/args,
/*Function*/canceller,
/*Function*/okHandler,
/*Function*/errHandler){
// summary:
// sets up the Deferred and ioArgs property on the Deferred so it
// can be used in an io call.
// args:
// The args object passed into the public io call. Recognized properties on
// the args object are:
// canceller:
// The canceller function used for the Deferred object. The function
// will receive one argument, the Deferred object that is related to the
// canceller.
// okHandler:
// The first OK callback to be registered with Deferred. It has the opportunity
// to transform the OK response. It will receive one argument -- the Deferred
// object returned from this function.
// errHandler:
// The first error callback to be registered with Deferred. It has the opportunity
// to do cleanup on an error. It will receive two arguments: error (the
// Error object) and dfd, the Deferred object returned from this function.
var ioArgs = {args: args, url: args.url};
//Get values from form if requestd.
var formObject = null;
if(args.form){
var form = dom.byId(args.form);
//IE requires going through getAttributeNode instead of just getAttribute in some form cases,
//so use it for all. See #2844
var actnNode = form.getAttributeNode("action");
ioArgs.url = ioArgs.url || (actnNode ? actnNode.value : null);
formObject = domForm.toObject(form);
}
// set up the query params
var miArgs = [{}];
if(formObject){
// potentially over-ride url-provided params w/ form values
miArgs.push(formObject);
}
if(args.content){
// stuff in content over-rides what's set by form
miArgs.push(args.content);
}
if(args.preventCache){
miArgs.push({"dojo.preventCache": new Date().valueOf()});
}
ioArgs.query = ioq.objectToQuery(lang.mixin.apply(null, miArgs));
// .. and the real work of getting the deferred in order, etc.
ioArgs.handleAs = args.handleAs || "text";
var d = new deferred(canceller);
d.addCallbacks(okHandler, function(error){
return errHandler(error, d);
});
//Support specifying load, error and handle callback functions from the args.
//For those callbacks, the "this" object will be the args object.
//The callbacks will get the deferred result value as the
//first argument and the ioArgs object as the second argument.
var ld = args.load;
if(ld && lang.isFunction(ld)){
d.addCallback(function(value){
return ld.call(args, value, ioArgs);
});
}
var err = args.error;
if(err && lang.isFunction(err)){
d.addErrback(function(value){
return err.call(args, value, ioArgs);
});
}
var handle = args.handle;
if(handle && lang.isFunction(handle)){
d.addBoth(function(value){
return handle.call(args, value, ioArgs);
});
}
//Plug in topic publishing, if dojo.publish is loaded.
if(cfg.ioPublish && dojo.publish && ioArgs.args.ioPublish !== false){
d.addCallbacks(
function(res){
dojo.publish("/dojo/io/load", [d, res]);
return res;
},
function(res){
dojo.publish("/dojo/io/error", [d, res]);
return res;
}
);
d.addBoth(function(res){
dojo.publish("/dojo/io/done", [d, res]);
return res;
});
}
d.ioArgs = ioArgs;
// FIXME: need to wire up the xhr object's abort method to something
// analagous in the Deferred
return d;
};
var _deferredCancel = function(/*Deferred*/dfd){
// summary: canceller function for dojo._ioSetArgs call.
dfd.canceled = true;
var xhr = dfd.ioArgs.xhr;
var _at = typeof xhr.abort;
if(_at == "function" || _at == "object" || _at == "unknown"){
xhr.abort();
}
var err = dfd.ioArgs.error;
if(!err){
err = new Error("xhr cancelled");
err.dojoType="cancel";
}
return err;
};
var _deferredOk = function(/*Deferred*/dfd){
// summary: okHandler function for dojo._ioSetArgs call.
var ret = handlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);
return ret === undefined ? null : ret;
};
var _deferError = function(/*Error*/error, /*Deferred*/dfd){
// summary: errHandler function for dojo._ioSetArgs call.
if(!dfd.ioArgs.args.failOk){
console.error(error);
}
return error;
};
// avoid setting a timer per request. It degrades performance on IE
// something fierece if we don't use unified loops.
var _inFlightIntvl = null;
var _inFlight = [];
//Use a separate count for knowing if we are starting/stopping io calls.
//Cannot use _inFlight.length since it can change at a different time than
//when we want to do this kind of test. We only want to decrement the count
//after a callback/errback has finished, since the callback/errback should be
//considered as part of finishing a request.
var _pubCount = 0;
var _checkPubCount = function(dfd){
if(_pubCount <= 0){
_pubCount = 0;
if(cfg.ioPublish && dojo.publish && (!dfd || dfd && dfd.ioArgs.args.ioPublish !== false)){
dojo.publish("/dojo/io/stop");
}
}
};
var _watchInFlight = function(){
//summary:
// internal method that checks each inflight XMLHttpRequest to see
// if it has completed or if the timeout situation applies.
var now = (new Date()).getTime();
// make sure sync calls stay thread safe, if this callback is called
// during a sync call and this results in another sync call before the
// first sync call ends the browser hangs
if(!dojo._blockAsync){
// we need manual loop because we often modify _inFlight (and therefore 'i') while iterating
// note: the second clause is an assigment on purpose, lint may complain
for(var i = 0, tif; i < _inFlight.length && (tif = _inFlight[i]); i++){
var dfd = tif.dfd;
var func = function(){
if(!dfd || dfd.canceled || !tif.validCheck(dfd)){
_inFlight.splice(i--, 1);
_pubCount -= 1;
}else if(tif.ioCheck(dfd)){
_inFlight.splice(i--, 1);
tif.resHandle(dfd);
_pubCount -= 1;
}else if(dfd.startTime){
//did we timeout?
if(dfd.startTime + (dfd.ioArgs.args.timeout || 0) < now){
_inFlight.splice(i--, 1);
var err = new Error("timeout exceeded");
err.dojoType = "timeout";
dfd.errback(err);
//Cancel the request so the io module can do appropriate cleanup.
dfd.cancel();
_pubCount -= 1;
}
}
};
if(dojo.config.debugAtAllCosts){
func.call(this);
}else{
try{
func.call(this);
}catch(e){
dfd.errback(e);
}
}
}
}
_checkPubCount(dfd);
if(!_inFlight.length){
clearInterval(_inFlightIntvl);
_inFlightIntvl = null;
}
};
dojo._ioCancelAll = function(){
//summary: Cancels all pending IO requests, regardless of IO type
//(xhr, script, iframe).
try{
array.forEach(_inFlight, function(i){
try{
i.dfd.cancel();
}catch(e){/*squelch*/}
});
}catch(e){/*squelch*/}
};
//Automatically call cancel all io calls on unload
//in IE for trac issue #2357.
if(has("ie")){
on(window, "unload", dojo._ioCancelAll);
}
dojo._ioNotifyStart = function(/*Deferred*/dfd){
// summary:
// If dojo.publish is available, publish topics
// about the start of a request queue and/or the
// the beginning of request.
// description:
// Used by IO transports. An IO transport should
// call this method before making the network connection.
if(cfg.ioPublish && dojo.publish && dfd.ioArgs.args.ioPublish !== false){
if(!_pubCount){
dojo.publish("/dojo/io/start");
}
_pubCount += 1;
dojo.publish("/dojo/io/send", [dfd]);
}
};
dojo._ioWatch = function(dfd, validCheck, ioCheck, resHandle){
// summary:
// Watches the io request represented by dfd to see if it completes.
// dfd: Deferred
// The Deferred object to watch.
// validCheck: Function
// Function used to check if the IO request is still valid. Gets the dfd
// object as its only argument.
// ioCheck: Function
// Function used to check if basic IO call worked. Gets the dfd
// object as its only argument.
// resHandle: Function
// Function used to process response. Gets the dfd
// object as its only argument.
var args = dfd.ioArgs.args;
if(args.timeout){
dfd.startTime = (new Date()).getTime();
}
_inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle});
if(!_inFlightIntvl){
_inFlightIntvl = setInterval(_watchInFlight, 50);
}
// handle sync requests
//A weakness: async calls in flight
//could have their handlers called as part of the
//_watchInFlight call, before the sync's callbacks
// are called.
if(args.sync){
_watchInFlight();
}
};
var _defaultContentType = "application/x-www-form-urlencoded";
var _validCheck = function(/*Deferred*/dfd){
return dfd.ioArgs.xhr.readyState; //boolean
};
var _ioCheck = function(/*Deferred*/dfd){
return 4 == dfd.ioArgs.xhr.readyState; //boolean
};
var _resHandle = function(/*Deferred*/dfd){
var xhr = dfd.ioArgs.xhr;
if(dojo._isDocumentOk(xhr)){
dfd.callback(dfd);
}else{
var err = new Error("Unable to load " + dfd.ioArgs.url + " status:" + xhr.status);
err.status = xhr.status;
err.responseText = xhr.responseText;
err.xhr = xhr;
dfd.errback(err);
}
};
dojo._ioAddQueryToUrl = function(/*dojo.__IoCallbackArgs*/ioArgs){
//summary: Adds query params discovered by the io deferred construction to the URL.
//Only use this for operations which are fundamentally GET-type operations.
if(ioArgs.query.length){
ioArgs.url += (ioArgs.url.indexOf("?") == -1 ? "?" : "&") + ioArgs.query;
ioArgs.query = null;
}
};
/*=====
dojo.declare("dojo.__XhrArgs", dojo.__IoArgs, {
constructor: function(){
// summary:
// In addition to the properties listed for the dojo._IoArgs type,
// the following properties are allowed for dojo.xhr* methods.
// handleAs: String?
// Acceptable values are: text (default), json, json-comment-optional,
// json-comment-filtered, javascript, xml. See `dojo.contentHandlers`
// sync: Boolean?
// false is default. Indicates whether the request should
// be a synchronous (blocking) request.
// headers: Object?
// Additional HTTP headers to send in the request.
// failOk: Boolean?
// false is default. Indicates whether a request should be
// allowed to fail (and therefore no console error message in
// the event of a failure)
// contentType: String|Boolean
// "application/x-www-form-urlencoded" is default. Set to false to
// prevent a Content-Type header from being sent, or to a string
// to send a different Content-Type.
this.handleAs = handleAs;
this.sync = sync;
this.headers = headers;
this.failOk = failOk;
}
});
=====*/
dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){
// summary:
// Sends an HTTP request with the given method.
// description:
// Sends an HTTP request with the given method.
// See also dojo.xhrGet(), xhrPost(), xhrPut() and dojo.xhrDelete() for shortcuts
// for those HTTP methods. There are also methods for "raw" PUT and POST methods
// via dojo.rawXhrPut() and dojo.rawXhrPost() respectively.
// method:
// HTTP method to be used, such as GET, POST, PUT, DELETE. Should be uppercase.
// hasBody:
// If the request has an HTTP body, then pass true for hasBody.
//Make the Deferred object for this xhr request.
var dfd = dojo._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError);
var ioArgs = dfd.ioArgs;
//Pass the args to _xhrObj, to allow alternate XHR calls based specific calls, like
//the one used for iframe proxies.
var xhr = ioArgs.xhr = dojo._xhrObj(ioArgs.args);
//If XHR factory fails, cancel the deferred.
if(!xhr){
dfd.cancel();
return dfd;
}
//Allow for specifying the HTTP body completely.
if("postData" in args){
ioArgs.query = args.postData;
}else if("putData" in args){
ioArgs.query = args.putData;
}else if("rawBody" in args){
ioArgs.query = args.rawBody;
}else if((arguments.length > 2 && !hasBody) || "POST|PUT".indexOf(method.toUpperCase()) == -1){
//Check for hasBody being passed. If no hasBody,
//then only append query string if not a POST or PUT request.
dojo._ioAddQueryToUrl(ioArgs);
}
// IE 6 is a steaming pile. It won't let you call apply() on the native function (xhr.open).
// workaround for IE6's apply() "issues"
xhr.open(method, ioArgs.url, args.sync !== true, args.user || undefined, args.password || undefined);
if(args.headers){
for(var hdr in args.headers){
if(hdr.toLowerCase() === "content-type" && !args.contentType){
args.contentType = args.headers[hdr];
}else if(args.headers[hdr]){
//Only add header if it has a value. This allows for instnace, skipping
//insertion of X-Requested-With by specifying empty value.
xhr.setRequestHeader(hdr, args.headers[hdr]);
}
}
}
// FIXME: is this appropriate for all content types?
if(args.contentType !== false){
xhr.setRequestHeader("Content-Type", args.contentType || _defaultContentType);
}
if(!args.headers || !("X-Requested-With" in args.headers)){
xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
}
// FIXME: set other headers here!
dojo._ioNotifyStart(dfd);
if(dojo.config.debugAtAllCosts){
xhr.send(ioArgs.query);
}else{
try{
xhr.send(ioArgs.query);
}catch(e){
ioArgs.error = e;
dfd.cancel();
}
}
dojo._ioWatch(dfd, _validCheck, _ioCheck, _resHandle);
xhr = null;
return dfd; // dojo.Deferred
};
dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){
// summary:
// Sends an HTTP GET request to the server.
return dojo.xhr("GET", args); // dojo.Deferred
};
dojo.rawXhrPost = dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){
// summary:
// Sends an HTTP POST request to the server. In addtion to the properties
// listed for the dojo.__XhrArgs type, the following property is allowed:
// postData:
// String. Send raw data in the body of the POST request.
return dojo.xhr("POST", args, true); // dojo.Deferred
};
dojo.rawXhrPut = dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){
// summary:
// Sends an HTTP PUT request to the server. In addtion to the properties
// listed for the dojo.__XhrArgs type, the following property is allowed:
// putData:
// String. Send raw data in the body of the PUT request.
return dojo.xhr("PUT", args, true); // dojo.Deferred
};
dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){
// summary:
// Sends an HTTP DELETE request to the server.
return dojo.xhr("DELETE", args); //dojo.Deferred
};
/*
dojo.wrapForm = function(formNode){
//summary:
// A replacement for FormBind, but not implemented yet.
// FIXME: need to think harder about what extensions to this we might
// want. What should we allow folks to do w/ this? What events to
// set/send?
throw new Error("dojo.wrapForm not yet implemented");
}
*/
dojo._isDocumentOk = function(http){
var stat = http.status || 0;
stat =
(stat >= 200 && stat < 300) || // allow any 2XX response code
stat == 304 || // or, get it out of the cache
stat == 1223 || // or, Internet Explorer mangled the status code
!stat; // or, we're Titanium/browser chrome/chrome extension requesting a local file
return stat; // Boolean
};
dojo._getText = function(url){
var result;
dojo.xhrGet({url:url, sync:true, load:function(text){
result = text;
}});
return result;
};
// Add aliases for static functions to dojo.xhr since dojo.xhr is what's returned from this module
lang.mixin(dojo.xhr, {
_xhrObj: dojo._xhrObj,
fieldToObject: domForm.fieldToObject,
formToObject: domForm.toObject,
objectToQuery: ioq.objectToQuery,
formToQuery: domForm.toQuery,
formToJson: domForm.toJson,
queryToObject: ioq.queryToObject,
contentHandlers: handlers,
_ioSetArgs: dojo._ioSetArgs,
_ioCancelAll: dojo._ioCancelAll,
_ioNotifyStart: dojo._ioNotifyStart,
_ioWatch: dojo._ioWatch,
_ioAddQueryToUrl: dojo._ioAddQueryToUrl,
_isDocumentOk: dojo._isDocumentOk,
_getText: dojo._getText,
get: dojo.xhrGet,
post: dojo.xhrPost,
put: dojo.xhrPut,
del: dojo.xhrDelete // because "delete" is a reserved word
});
return dojo.xhr;
});