From e44a7e37b6c7b5961adaffc62b9042b8d442938e Mon Sep 17 00:00:00 2001 From: mensonge Date: Thu, 13 Nov 2008 09:49:11 +0000 Subject: New feature: basic Ajax suggestion for tags and implementation of Dojo toolkit git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f --- includes/js/dojo/_base/Color.js | 156 +++ includes/js/dojo/_base/Deferred.js | 408 +++++++ includes/js/dojo/_base/NodeList.js | 532 +++++++++ includes/js/dojo/_base/_loader/bootstrap.js | 436 +++++++ includes/js/dojo/_base/_loader/hostenv_browser.js | 379 ++++++ includes/js/dojo/_base/_loader/hostenv_rhino.js | 238 ++++ .../js/dojo/_base/_loader/hostenv_spidermonkey.js | 80 ++ includes/js/dojo/_base/_loader/loader.js | 690 +++++++++++ includes/js/dojo/_base/_loader/loader_debug.js | 61 + includes/js/dojo/_base/_loader/loader_xd.js | 631 ++++++++++ includes/js/dojo/_base/array.js | 182 +++ includes/js/dojo/_base/browser.js | 21 + includes/js/dojo/_base/connect.js | 285 +++++ includes/js/dojo/_base/declare.js | 178 +++ includes/js/dojo/_base/event.js | 529 +++++++++ includes/js/dojo/_base/fx.js | 584 ++++++++++ includes/js/dojo/_base/html.js | 1227 ++++++++++++++++++++ includes/js/dojo/_base/json.js | 137 +++ includes/js/dojo/_base/lang.js | 257 ++++ includes/js/dojo/_base/query.js | 1191 +++++++++++++++++++ includes/js/dojo/_base/window.js | 145 +++ includes/js/dojo/_base/xhr.js | 730 ++++++++++++ 22 files changed, 9077 insertions(+) create mode 100644 includes/js/dojo/_base/Color.js create mode 100644 includes/js/dojo/_base/Deferred.js create mode 100644 includes/js/dojo/_base/NodeList.js create mode 100644 includes/js/dojo/_base/_loader/bootstrap.js create mode 100644 includes/js/dojo/_base/_loader/hostenv_browser.js create mode 100644 includes/js/dojo/_base/_loader/hostenv_rhino.js create mode 100644 includes/js/dojo/_base/_loader/hostenv_spidermonkey.js create mode 100644 includes/js/dojo/_base/_loader/loader.js create mode 100644 includes/js/dojo/_base/_loader/loader_debug.js create mode 100644 includes/js/dojo/_base/_loader/loader_xd.js create mode 100644 includes/js/dojo/_base/array.js create mode 100644 includes/js/dojo/_base/browser.js create mode 100644 includes/js/dojo/_base/connect.js create mode 100644 includes/js/dojo/_base/declare.js create mode 100644 includes/js/dojo/_base/event.js create mode 100644 includes/js/dojo/_base/fx.js create mode 100644 includes/js/dojo/_base/html.js create mode 100644 includes/js/dojo/_base/json.js create mode 100644 includes/js/dojo/_base/lang.js create mode 100644 includes/js/dojo/_base/query.js create mode 100644 includes/js/dojo/_base/window.js create mode 100644 includes/js/dojo/_base/xhr.js (limited to 'includes/js/dojo/_base') diff --git a/includes/js/dojo/_base/Color.js b/includes/js/dojo/_base/Color.js new file mode 100644 index 0000000..38d0584 --- /dev/null +++ b/includes/js/dojo/_base/Color.js @@ -0,0 +1,156 @@ +if(!dojo._hasResource["dojo._base.Color"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.Color"] = true; +dojo.provide("dojo._base.Color"); +dojo.require("dojo._base.array"); +dojo.require("dojo._base.lang"); + +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 + if(color){ this.setColor(color); } +}; + +// FIXME: there's got to be a more space-efficient way to encode or discover these!! Use hex? +dojo.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] +}; + + +dojo.extend(dojo.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 + var d = dojo; + if(d.isString(color)){ + d.colorFromString(color, this); + }else if(d.isArray(color)){ + d.colorFromArray(color, this); + }else{ + this._set(color.r, color.g, color.b, color.a); + if(!(color instanceof d.Color)){ this.sanitize(); } + } + return this; // dojo.Color + }, + sanitize: function(){ + // summary: + // makes sure that the object has correct attributes + // description: + // the default implementation does nothing, include dojo.colors to + // augment it to real checks + return this; // dojo.Color + }, + toRgb: function(){ + // summary: returns 3 component array of rgb values + var t = this; + return [t.r, t.g, t.b]; // Array + }, + toRgba: function(){ + // summary: returns a 4 component array of rgba values + var t = this; + return [t.r, t.g, t.b, t.a]; // Array + }, + toHex: function(){ + // summary: returns a css color string in hexadecimal representation + var arr = dojo.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 + 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 + } +}); + +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 d = dojo, t = obj || new dojo.Color(); + d.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 +}; + +dojo.colorFromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){ + // summary: get rgb(a) array from css-style color declarations + var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/); + return m && dojo.colorFromArray(m[1].split(/\s*,\s*/), obj); // dojo.Color +}; + +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. + var d = dojo, t = obj || new d.Color(), + bits = (color.length == 4) ? 4 : 8, + mask = (1 << bits) - 1; + color = Number("0x" + color.substr(1)); + if(isNaN(color)){ + return null; // dojo.Color + } + d.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 +}; + +dojo.colorFromArray = function(/*Array*/ a, /*dojo.Color?*/ obj){ + // summary: builds a color from 1, 2, 3, or 4 element array + var t = obj || new dojo.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 +}; + +dojo.colorFromString = function(/*String*/ str, /*dojo.Color?*/ obj){ + // summary: + // parses str for a color value. + // 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 = dojo.Color.named[str]; + return a && dojo.colorFromArray(a, obj) || dojo.colorFromRgb(str, obj) || dojo.colorFromHex(str, obj); +}; + +} diff --git a/includes/js/dojo/_base/Deferred.js b/includes/js/dojo/_base/Deferred.js new file mode 100644 index 0000000..9fe8918 --- /dev/null +++ b/includes/js/dojo/_base/Deferred.js @@ -0,0 +1,408 @@ +if(!dojo._hasResource["dojo._base.Deferred"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.Deferred"] = true; +dojo.provide("dojo._base.Deferred"); +dojo.require("dojo._base.lang"); + +dojo.Deferred = function(/*Function?*/ canceller){ + // summary: + // Encapsulates a sequence of callbacks in response to a value that + // may not yet be available. This is modeled after the Deferred class + // from Twisted . + // description: + // JavaScript has no threads, and even if it did, threads are hard. + // Deferreds are a way of abstracting non-blocking events, such as the + // final response to an XMLHttpRequest. Deferreds create a promise to + // return a response a some point in the future and an easy way to + // register your interest in receiving that response. + // + // The most important methods for Deffered users are: + // + // * addCallback(handler) + // * addErrback(handler) + // * callback(result) + // * errback(result) + // + // In general, when a function returns a Deferred, users then "fill + // in" the second half of the contract by registering callbacks and + // error handlers. You may register as many callback and errback + // handlers as you like and they will be executed in the order + // registered when a result is provided. Usually this result is + // provided as the result of an asynchronous operation. The code + // "managing" the Deferred (the code that made the promise to provide + // an answer later) will use the callback() and errback() methods to + // communicate with registered listeners about the result of the + // operation. At this time, all registered result handlers are called + // *with the most recent result value*. + // + // Deferred callback handlers are treated as a chain, and each item in + // the chain is required to return a value that will be fed into + // successive handlers. The most minimal callback may be registered + // like this: + // + // | var d = new dojo.Deferred(); + // | d.addCallback(function(result){ return result; }); + // + // Perhaps the most common mistake when first using Deferreds is to + // forget to return a value (in most cases, the value you were + // passed). + // + // The sequence of callbacks is internally represented as a list of + // 2-tuples containing the callback/errback pair. For example, the + // following call sequence: + // + // | var d = new dojo.Deferred(); + // | d.addCallback(myCallback); + // | d.addErrback(myErrback); + // | d.addBoth(myBoth); + // | d.addCallbacks(myCallback, myErrback); + // + // is translated into a Deferred with the following internal + // representation: + // + // | [ + // | [myCallback, null], + // | [null, myErrback], + // | [myBoth, myBoth], + // | [myCallback, myErrback] + // | ] + // + // The Deferred also keeps track of its current status (fired). Its + // status may be one of three things: + // + // * -1: no value yet (initial condition) + // * 0: success + // * 1: error + // + // A Deferred will be in the error state if one of the following three + // conditions are met: + // + // 1. The result given to callback or errback is "instanceof" Error + // 2. The previous callback or errback raised an exception while + // executing + // 3. The previous callback or errback returned a value + // "instanceof" Error + // + // Otherwise, the Deferred will be in the success state. The state of + // the Deferred determines the next element in the callback sequence + // to run. + // + // When a callback or errback occurs with the example deferred chain, + // something equivalent to the following will happen (imagine + // that exceptions are caught and returned): + // + // | // d.callback(result) or d.errback(result) + // | if(!(result instanceof Error)){ + // | result = myCallback(result); + // | } + // | if(result instanceof Error){ + // | result = myErrback(result); + // | } + // | result = myBoth(result); + // | if(result instanceof Error){ + // | result = myErrback(result); + // | }else{ + // | result = myCallback(result); + // | } + // + // The result is then stored away in case another step is added to the + // callback sequence. Since the Deferred already has a value + // available, any new callbacks added will be called immediately. + // + // There are two other "advanced" details about this implementation + // that are useful: + // + // Callbacks are allowed to return Deferred instances themselves, so + // you can build complicated sequences of events with ease. + // + // The creator of the Deferred may specify a canceller. The canceller + // is a function that will be called if Deferred.cancel is called + // before the Deferred fires. You can use this to implement clean + // aborting of an XMLHttpRequest, etc. Note that cancel will fire the + // deferred with a CancelledError (unless your canceller returns + // another kind of error), so the errbacks should be prepared to + // handle that error for cancellable Deferreds. + // 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).addErrback(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 syncrhonous 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).addErrback(function(){ + // | promptUserToRecover(); + // | }); + // + // Note that the caller doesn't have to change his code at all to + // handle the asynchronous case. + + this.chain = []; + this.id = this._nextId(); + this.fired = -1; + this.paused = 0; + this.results = [null, null]; + this.canceller = canceller; + this.silentlyCancelled = false; +}; + +dojo.extend(dojo.Deferred, { + /* + makeCalled: function(){ + // summary: + // returns a new, empty deferred, which is already in the called + // state. Calling callback() or errback() on this deferred will + // yeild an error and adding new handlers to it will result in + // them being called immediately. + var deferred = new dojo.Deferred(); + deferred.callback(); + return deferred; + }, + + toString: function(){ + var state; + if(this.fired == -1){ + state = 'unfired'; + }else{ + state = this.fired ? 'success' : 'error'; + } + return 'Deferred(' + this.id + ', ' + state + ')'; + }, + */ + + _nextId: (function(){ + var n = 1; + return function(){ return n++; }; + })(), + + cancel: function(){ + // summary: + // Cancels a Deferred that has not yet received a value, or is + // waiting on another Deferred as its value. + // description: + // If a canceller is defined, the canceller is called. If the + // canceller did not return an error, or there was no canceller, + // then the errback chain is started. + var err; + if(this.fired == -1){ + if(this.canceller){ + err = this.canceller(this); + }else{ + this.silentlyCancelled = true; + } + if(this.fired == -1){ + if(!(err instanceof Error)){ + var res = err; + err = new Error("Deferred Cancelled"); + err.dojoType = "cancel"; + err.cancelResult = res; + } + this.errback(err); + } + }else if( (this.fired == 0) && + (this.results[0] instanceof dojo.Deferred) + ){ + this.results[0].cancel(); + } + }, + + + _resback: function(res){ + // summary: + // The private primitive that means either callback or errback + this.fired = ((res instanceof Error) ? 1 : 0); + this.results[this.fired] = res; + this._fire(); + }, + + _check: function(){ + if(this.fired != -1){ + if(!this.silentlyCancelled){ + throw new Error("already called!"); + } + this.silentlyCancelled = false; + return; + } + }, + + callback: function(res){ + // summary: + // Begin the callback sequence with a non-error value. + + /* + callback or errback should only be called once on a given + Deferred. + */ + this._check(); + this._resback(res); + }, + + errback: function(/*Error*/res){ + // summary: + // Begin the callback sequence with an error result. + this._check(); + if(!(res instanceof Error)){ + res = new Error(res); + } + this._resback(res); + }, + + addBoth: function(/*Function|Object*/cb, /*String?*/cbfn){ + // summary: + // Add the same function as both a callback and an errback as the + // next element on the callback sequence.This is useful for code + // that you want to guarantee to run, e.g. a finalizer. + var enclosed = dojo.hitch.apply(dojo, arguments); + return this.addCallbacks(enclosed, enclosed); + }, + + addCallback: function(/*Function|Object*/cb, /*String?*/cbfn /*...*/){ + // summary: + // Add a single callback to the end of the callback sequence. + return this.addCallbacks(dojo.hitch.apply(dojo, arguments)); + }, + + addErrback: function(cb, cbfn){ + // summary: + // Add a single callback to the end of the callback sequence. + return this.addCallbacks(null, dojo.hitch.apply(dojo, arguments)); + }, + + addCallbacks: function(cb, eb){ + // summary: + // Add separate callback and errback to the end of the callback + // sequence. + this.chain.push([cb, eb]) + if(this.fired >= 0){ + this._fire(); + } + return this; + }, + + _fire: function(){ + // summary: + // Used internally to exhaust the callback sequence when a result + // is available. + var chain = this.chain; + var fired = this.fired; + var res = this.results[fired]; + var self = this; + var cb = null; + while( + (chain.length > 0) && + (this.paused == 0) + ){ + // Array + var f = chain.shift()[fired]; + if(!f){ continue; } + try{ + res = f(res); + fired = ((res instanceof Error) ? 1 : 0); + if(res instanceof dojo.Deferred){ + cb = function(res){ + self._resback(res); + // inlined from _pause() + self.paused--; + if( + (self.paused == 0) && + (self.fired >= 0) + ){ + self._fire(); + } + } + // inlined from _unpause + this.paused++; + } + }catch(err){ + console.debug(err); + fired = 1; + res = err; + } + } + this.fired = fired; + this.results[fired] = res; + if((cb)&&(this.paused)){ + // this is for "tail recursion" in case the dependent + // deferred is already fired + res.addBoth(cb); + } + } +}); + +} diff --git a/includes/js/dojo/_base/NodeList.js b/includes/js/dojo/_base/NodeList.js new file mode 100644 index 0000000..c10e18d --- /dev/null +++ b/includes/js/dojo/_base/NodeList.js @@ -0,0 +1,532 @@ +if(!dojo._hasResource["dojo._base.NodeList"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.NodeList"] = true; +dojo.provide("dojo._base.NodeList"); +dojo.require("dojo._base.lang"); +dojo.require("dojo._base.array"); + +(function(){ + + var d = dojo; + + var tnl = function(arr){ + // decorate an array to make it look like a NodeList + arr.constructor = dojo.NodeList; + dojo._mixin(arr, dojo.NodeList.prototype); + return arr; + } + + var _mapIntoDojo = function(func, alwaysThis){ + // returns a function which, when executed in the scope of its caller, + // applies the passed arguments to a particular dojo.* function (named + // in func) and aggregates the returns. if alwaysThis is true, it + // always returns the scope object and not the collected returns from + // the Dojo method + return function(){ + var _a = arguments; + var aa = d._toArray(_a, 0, [null]); + var s = this.map(function(i){ + aa[0] = i; + return d[func].apply(d, aa); + }); + return (alwaysThis || ( (_a.length > 1) || !d.isString(_a[0]) )) ? this : s; // String||dojo.NodeList + } + }; + + dojo.NodeList = function(){ + // summary: + // dojo.NodeList is as subclass of Array which adds syntactic + // sugar for chaining, common iteration operations, animation, + // and node manipulation. NodeLists are most often returned as + // the result of dojo.query() calls. + // example: + // create a node list from a node + // | new dojo.NodeList(dojo.byId("foo")); + + return tnl(Array.apply(null, arguments)); + } + + dojo.NodeList._wrap = tnl; + + dojo.extend(dojo.NodeList, { + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods + + // FIXME: handle return values for #3244 + // http://trac.dojotoolkit.org/ticket/3244 + + // FIXME: + // need to wrap or implement: + // join (perhaps w/ innerHTML/outerHTML overload for toString() of items?) + // reduce + // reduceRight + + slice: function(/*===== begin, end =====*/){ + // summary: + // Returns a new NodeList, maintaining this one in place + // description: + // This method behaves exactly like the Array.slice method + // with the caveat that it returns a dojo.NodeList and not a + // raw Array. For more details, see: + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:slice + // begin: Integer + // Can be a positive or negative integer, with positive + // integers noting the offset to begin at, and negative + // integers denoting an offset from the end (i.e., to the left + // of the end) + // end: Integer? + // Optional parameter to describe what position relative to + // the NodeList's zero index to end the slice at. Like begin, + // can be positive or negative. + var a = dojo._toArray(arguments); + return tnl(a.slice.apply(this, a)); + }, + + splice: function(/*===== index, howmany, item =====*/){ + // summary: + // Returns a new NodeList, manipulating this NodeList based on + // the arguments passed, potentially splicing in new elements + // at an offset, optionally deleting elements + // description: + // This method behaves exactly like the Array.splice method + // with the caveat that it returns a dojo.NodeList and not a + // raw Array. For more details, see: + // + // index: Integer + // begin can be a positive or negative integer, with positive + // integers noting the offset to begin at, and negative + // integers denoting an offset from the end (i.e., to the left + // of the end) + // howmany: Integer? + // Optional parameter to describe what position relative to + // the NodeList's zero index to end the slice at. Like begin, + // can be positive or negative. + // item: Object...? + // Any number of optional parameters may be passed in to be + // spliced into the NodeList + // returns: + // dojo.NodeList + var a = dojo._toArray(arguments); + return tnl(a.splice.apply(this, a)); + }, + + concat: function(/*===== item =====*/){ + // summary: + // Returns a new NodeList comprised of items in this NodeList + // as well as items passed in as parameters + // description: + // This method behaves exactly like the Array.concat method + // with the caveat that it returns a dojo.NodeList and not a + // raw Array. For more details, see: + // + // item: Object...? + // Any number of optional parameters may be passed in to be + // spliced into the NodeList + // returns: + // dojo.NodeList + var a = dojo._toArray(arguments, 0, [this]); + return tnl(a.concat.apply([], a)); + }, + + indexOf: function(/*Object*/ value, /*Integer?*/ fromIndex){ + // summary: + // see dojo.indexOf(). The primary difference is that the acted-on + // array is implicitly this NodeList + // value: + // The value to search for. + // fromIndex: + // The loction to start searching from. Optional. Defaults to 0. + // description: + // For more details on the behavior of indexOf, see: + // + // returns: + // Positive Integer or 0 for a match, -1 of not found. + return d.indexOf(this, value, fromIndex); // Integer + }, + + lastIndexOf: function(/*===== value, fromIndex =====*/){ + // summary: + // see dojo.lastIndexOf(). The primary difference is that the + // acted-on array is implicitly this NodeList + // description: + // For more details on the behavior of lastIndexOf, see: + // + // value: Object + // The value to search for. + // fromIndex: Integer? + // The loction to start searching from. Optional. Defaults to 0. + // returns: + // Positive Integer or 0 for a match, -1 of not found. + return d.lastIndexOf.apply(d, d._toArray(arguments, 0, [this])); // Integer + }, + + every: function(/*Function*/callback, /*Object?*/thisObject){ + // summary: + // see `dojo.every()` and: + // + // Takes the same structure of arguments and returns as + // dojo.every() with the caveat that the passed array is + // implicitly this NodeList + return d.every(this, callback, thisObject); // Boolean + }, + + some: function(/*Function*/callback, /*Object?*/thisObject){ + // summary: + // see dojo.some() and: + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some + // Takes the same structure of arguments and returns as + // dojo.some() with the caveat that the passed array is + // implicitly this NodeList + return d.some(this, callback, thisObject); // Boolean + }, + + map: function(/*Function*/ func, /*Function?*/ obj){ + // summary: + // see dojo.map(). The primary difference is that the acted-on + // array is implicitly this NodeList and the return is a + // dojo.NodeList (a subclass of Array) + + return d.map(this, func, obj, d.NodeList); // dojo.NodeList + }, + + forEach: function(callback, thisObj){ + // summary: + // see dojo.forEach(). The primary difference is that the acted-on + // array is implicitly this NodeList + + d.forEach(this, callback, thisObj); + // non-standard return to allow easier chaining + return this; // dojo.NodeList + }, + + // custom methods + + coords: function(){ + // summary: + // Returns the box objects all elements in a node list as + // an Array (*not* a NodeList) + + return d.map(this, d.coords); // Array + }, + + /*===== + attr: function(property, value){ + // summary: + // gets or sets the DOM attribute for every element in the + // NodeList + // property: String + // the attribute to get/set + // value: String? + // optional. The value to set the property to + // return: + // if no value is passed, the result is an array of attribute values + // If a value is passed, the return is this NodeList + }, + + style: function(property, value){ + // summary: + // gets or sets the CSS property for every element in the NodeList + // property: String + // the CSS property to get/set, in JavaScript notation + // ("lineHieght" instead of "line-height") + // value: String? + // optional. The value to set the property to + // return: + // if no value is passed, the result is an array of strings. + // If a value is passed, the return is this NodeList + }, + + addClass: function(className){ + // summary: + // adds the specified class to every node in the list + // className: String + // the CSS class to add + // return: + // dojo.NodeList, this list + }, + + removeClass: function(className){ + // summary: + // removes the specified class from every node in the list + // className: String + // the CSS class to add + // return: + // dojo.NodeList, this list + }, + + toggleClass: function(className, condition){ + // summary: + // Adds a class to node if not present, or removes if present. + // Pass a boolean condition if you want to explicitly add or remove. + // condition: Boolean? + // If passed, true means to add the class, false means to remove. + // className: String + // the CSS class to add + // return: dojo.NodeList + // this list + }, + + 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.debug("clicked!"); + // | }); + // example: + // attach foo.bar() to every odd div's onmouseover + // | dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar"); + }, + =====*/ + attr: _mapIntoDojo("attr"), + style: _mapIntoDojo("style"), + addClass: _mapIntoDojo("addClass", true), + removeClass: _mapIntoDojo("removeClass", true), + toggleClass: _mapIntoDojo("toggleClass", true), + connect: _mapIntoDojo("connect", true), + + // FIXME: connectPublisher()? connectRunOnce()? + + place: function(/*String||Node*/ queryOrNode, /*String*/ position){ + // summary: + // places elements of this node list relative to the first element matched + // by queryOrNode. Returns the original NodeList. + // queryOrNode: + // may be a string representing any valid CSS3 selector or a DOM node. + // In the selector case, only the first matching element will be used + // for relative positioning. + // position: + // can be one of: + // * "last"||"end" (default) + // * "first||"start" + // * "before" + // * "after" + // or an offset in the childNodes property + var item = d.query(queryOrNode)[0]; + return this.forEach(function(i){ d.place(i, item, (position||"last")); }); // dojo.NodeList + }, + + orphan: function(/*String?*/ simpleFilter){ + // summary: + // removes elements in this list that match the simple + // filter from their parents and returns them as a new + // NodeList. + // simpleFilter: + // single-expression CSS filter + // return: + // `dojo.NodeList` the orpahned elements + var orphans = simpleFilter ? d._filterQueryResult(this, simpleFilter) : this; + orphans.forEach(function(item){ + if(item.parentNode){ + item.parentNode.removeChild(item); + } + }); + return orphans; // dojo.NodeList + }, + + adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){ + // summary: + // places any/all elements in queryOrListOrNode at a + // position relative to the first element in this list. + // Returns a dojo.NodeList of the adopted elements. + // queryOrListOrNode: + // a DOM node or a query string or a query result. + // Represents the nodes to be adopted relative to the + // first element of this NodeList. + // position: + // can be one of: + // * "last"||"end" (default) + // * "first||"start" + // * "before" + // * "after" + // or an offset in the childNodes property + var item = this[0]; + return d.query(queryOrListOrNode).forEach(function(ai){ d.place(ai, item, position || "last"); }); // dojo.NodeList + }, + + // FIXME: do we need this? + query: function(/*String*/ queryStr){ + // summary: + // Returns a new, flattened NodeList. Elements of the new list + // satisfy the passed query but use elements of the + // current NodeList as query roots. + + if(!queryStr){ return this; } + + // FIXME: probably slow + // FIXME: use map? + var ret = d.NodeList(); + this.forEach(function(item){ + d.query(queryStr, item).forEach(function(subItem){ + if(subItem !== undefined){ + ret.push(subItem); + } + }); + }); + return ret; // dojo.NodeList + }, + + filter: function(/*String*/ simpleQuery){ + // summary: + // "masks" the built-in javascript filter() method to support + // passing a simple string filter in addition to supporting + // filtering function objects. + // example: + // "regular" JS filter syntax as exposed in dojo.filter: + // | dojo.query("*").filter(function(item){ + // | // highlight every paragraph + // | return (item.nodeName == "p"); + // | }).styles("backgroundColor", "yellow"); + // example: + // the same filtering using a CSS selector + // | dojo.query("*").filter("p").styles("backgroundColor", "yellow"); + + var items = this; + var _a = arguments; + var r = d.NodeList(); + var rp = function(t){ + if(t !== undefined){ + r.push(t); + } + } + if(d.isString(simpleQuery)){ + items = d._filterQueryResult(this, _a[0]); + if(_a.length == 1){ + // if we only got a string query, pass back the filtered results + return items; // dojo.NodeList + } + // if we got a callback, run it over the filtered items + _a.shift(); + } + // handle the (callback, [thisObject]) case + d.forEach(d.filter(items, _a[0], _a[1]), rp); + return r; // dojo.NodeList + }, + + /* + // FIXME: should this be "copyTo" and include parenting info? + clone: function(){ + // summary: + // creates node clones of each element of this list + // and returns a new list containing the clones + }, + */ + + addContent: function(/*String*/ content, /*String||Integer?*/ position){ + // summary: + // add a node or some HTML as a string to every item in the list. + // Returns the original list. + // description: + // a copy of the HTML content is added to each item in the + // list, with an optional position argument. If no position + // argument is provided, the content is appended to the end of + // each item. + // content: + // the HTML in string format to add at position to every item + // position: + // can be one of: + // * "last"||"end" (default) + // * "first||"start" + // * "before" + // * "after" + // or an offset in the childNodes property + // example: + // appends content to the end if the position is ommitted + // | dojo.query("h3 > p").addContent("hey there!"); + // example: + // add something to the front of each element that has a "thinger" property: + // | dojo.query("[thinger]").addContent("...", "first"); + // example: + // adds a header before each element of the list + // | dojo.query(".note").addContent("

NOTE:

", "before"); + var ta = d.doc.createElement("span"); + if(d.isString(content)){ + ta.innerHTML = content; + }else{ + ta.appendChild(content); + } + if(position === undefined){ + position = "last"; + } + var ct = (position == "first" || position == "after") ? "lastChild" : "firstChild"; + this.forEach(function(item){ + var tn = ta.cloneNode(true); + while(tn[ct]){ + d.place(tn[ct], item, position); + } + }); + return this; // dojo.NodeList + }, + + empty: function(){ + // summary: + // clears all content from each node in the list + return this.forEach("item.innerHTML='';"); // dojo.NodeList + + // FIXME: should we be checking for and/or disposing of widgets below these nodes? + }, + + instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){ + // summary: + // Create a new instance of a specified class, using the + // specified properties and each node in the nodeList as a + // srcNodeRef + // + var c = d.isFunction(declaredClass) ? declaredClass : d.getObject(declaredClass); + return this.forEach(function(i){ + new c(properties||{},i); + }) // dojo.NodeList + } + + }); + + // syntactic sugar for DOM events + d.forEach([ + "blur", "focus", "click", "keydown", "keypress", "keyup", "mousedown", + "mouseenter", "mouseleave", "mousemove", "mouseout", "mouseover", + "mouseup" + ], function(evt){ + var _oe = "on"+evt; + dojo.NodeList.prototype[_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.debug(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.debug(e); } + try{ n[_oe](_e); }catch(e){ console.debug(e); } + }) + ); + } + */ + } + ); + +})(); + +} diff --git a/includes/js/dojo/_base/_loader/bootstrap.js b/includes/js/dojo/_base/_loader/bootstrap.js new file mode 100644 index 0000000..c62ab6a --- /dev/null +++ b/includes/js/dojo/_base/_loader/bootstrap.js @@ -0,0 +1,436 @@ +/*===== +// note: +// 'djConfig' 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. + +djConfig = { + // summary: + // Application code can set the global 'djConfig' prior to loading + // the library to override certain global settings for how dojo works. + // + // isDebug: Boolean + // Defaults to `false`. If set to `true`, ensures that Dojo provides + // extende 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, + // debugAtAllCosts: Boolean + // Defaults to `false`. If set to `true`, this triggers an alternate + // mode of the package system in which dependencies are detected and + // only then are resources evaluated in dependency order via + // ` + // | + d._modulePrefixes[module] = { name: module, value: prefix }; + } + + dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){ + // summary: + // Declares translated resources and loads them if necessary, in the + // same style as dojo.require. Contents of the resource bundle are + // typically strings, but may be any name/value pair, represented in + // JSON format. See also dojo.i18n.getLocalization. + // moduleName: + // name of the package containing the "nls" directory in which the + // bundle is found + // bundleName: + // bundle name, i.e. the filename without the '.js' suffix + // locale: + // the locale to load (optional) By default, the browser's user + // locale as defined by dojo.locale + // availableFlatLocales: + // A comma-separated list of the available, flattened locales for this + // bundle. This argument should only be set by the build process. + // description: + // Load translated resource bundles provided underneath the "nls" + // directory within a package. Translated resources may be located in + // different packages throughout the source tree. For example, a + // particular widget may define one or more resource bundles, + // structured in a program as follows, where moduleName is + // mycode.mywidget and bundleNames available include bundleone and + // bundletwo: + // + // | ... + // | mycode/ + // | mywidget/ + // | nls/ + // | bundleone.js (the fallback translation, English in this example) + // | bundletwo.js (also a fallback translation) + // | de/ + // | bundleone.js + // | bundletwo.js + // | de-at/ + // | bundleone.js + // | en/ + // | (empty; use the fallback translation) + // | en-us/ + // | bundleone.js + // | en-gb/ + // | bundleone.js + // | es/ + // | bundleone.js + // | bundletwo.js + // | ...etc + // | ... + // + // Each directory is named for a locale as specified by RFC 3066, + // (http://www.ietf.org/rfc/rfc3066.txt), normalized in lowercase. + // Note that the two bundles in the example do not define all the + // same variants. For a given locale, bundles will be loaded for + // that locale and all more general locales above it, including a + // fallback at the root directory. For example, a declaration for + // the "de-at" locale will first load `nls/de-at/bundleone.js`, + // then `nls/de/bundleone.js` and finally `nls/bundleone.js`. The + // data will be flattened into a single Object so that lookups + // will follow this cascading pattern. An optional build step can + // preload the bundles to avoid data redundancy and the multiple + // network hits normally required to load these resources. + + d.require("dojo.i18n"); + d.i18n._requireLocalization.apply(d.hostenv, arguments); + }; + + + var ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"); + var ire = new RegExp("^((([^:]+:)?([^@]+))@)?([^:]*)(:([0-9]+))?$"); + + dojo._Url = function(/*dojo._Url||String...*/){ + // summary: + // Constructor to create an object representing a URL. + // It is marked as private, since we might consider removing + // or simplifying it. + // description: + // Each argument is evaluated in order relative to the next until + // a canonical uri is produced. To get an absolute Uri relative to + // the current document use: + // new dojo._Url(document.baseURI, url) + + var n = null; + + // TODO: support for IPv6, see RFC 2732 + var _a = arguments; + var 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 d._Url(_a[i]+""); + var uriobj = new d._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[5]; + this.port = r[7] || n; + } + } + + dojo._Url.prototype.toString = function(){ return this.uri; }; + + dojo.moduleUrl = function(/*String*/module, /*dojo._Url||String*/url){ + // summary: + // Returns a `dojo._Url` object 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"); + // | // NOTE: we assign the string representation of the url object + // | img.src = pngPath.toString(); + // | // 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"); + + var loc = d._getModuleSymbols(module).join('/'); + if(!loc){ return null; } + if(loc.lastIndexOf("/") != loc.length-1){ + loc += "/"; + } + + //If the path is an absolute path (starts with a / or is on another + //domain/xdomain) then don't add the baseUrl. + var colonIndex = loc.indexOf(":"); + if(loc.charAt(0) != "/" && (colonIndex == -1 || colonIndex > loc.indexOf("/"))){ + loc = d.baseUrl + loc; + } + + return new d._Url(loc, url); // String + } +})(); + +} diff --git a/includes/js/dojo/_base/_loader/loader_debug.js b/includes/js/dojo/_base/_loader/loader_debug.js new file mode 100644 index 0000000..7e52373 --- /dev/null +++ b/includes/js/dojo/_base/_loader/loader_debug.js @@ -0,0 +1,61 @@ +if(!dojo._hasResource["dojo._base._loader.loader_debug"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base._loader.loader_debug"] = true; +dojo.provide("dojo._base._loader.loader_debug"); + +//Override dojo.provide, so we can trigger the next +//script tag for the next local module. We can only add one +//at a time because there are browsers that execute script tags +//in the order that the code is received, and not in the DOM order. +dojo.nonDebugProvide = dojo.provide; + +dojo.provide = function(resourceName){ + var dbgQueue = dojo["_xdDebugQueue"]; + if(dbgQueue && dbgQueue.length > 0 && resourceName == dbgQueue["currentResourceName"]){ + //Set a timeout so the module can be executed into existence. Normally the + //dojo.provide call in a module is the first line. Don't want to risk attaching + //another script tag until the current one finishes executing. + if(dojo.isAIR){ + window.setTimeout(function(){dojo._xdDebugFileLoaded(resourceName);}, 1); + }else{ + window.setTimeout(dojo._scopeName + "._xdDebugFileLoaded('" + resourceName + "')", 1); + } + } + + return dojo.nonDebugProvide.apply(dojo, arguments); +} + +dojo._xdDebugFileLoaded = function(resourceName){ + + if(!this._xdDebugScopeChecked){ + //If using a scoped dojo, we need to expose dojo as a real global + //for the debugAtAllCosts stuff to work. + if(dojo._scopeName != "dojo"){ + window.dojo = window[dojo.config.scopeMap[0][1]]; + window.dijit = window[dojo.config.scopeMap[1][1]]; + window.dojox = window[dojo.config.scopeMap[2][1]]; + } + + this._xdDebugScopeChecked = true; + } + + var dbgQueue = this._xdDebugQueue; + + if(resourceName && resourceName == dbgQueue.currentResourceName){ + dbgQueue.shift(); + } + + if(dbgQueue.length == 0){ + dbgQueue.currentResourceName = null; + this._xdNotifyLoaded(); + }else{ + if(resourceName == dbgQueue.currentResourceName){ + dbgQueue.currentResourceName = dbgQueue[0].resourceName; + var element = document.createElement("script"); + element.type = "text/javascript"; + element.src = dbgQueue[0].resourcePath; + document.getElementsByTagName("head")[0].appendChild(element); + } + } +} + +} diff --git a/includes/js/dojo/_base/_loader/loader_xd.js b/includes/js/dojo/_base/_loader/loader_xd.js new file mode 100644 index 0000000..d851df8 --- /dev/null +++ b/includes/js/dojo/_base/_loader/loader_xd.js @@ -0,0 +1,631 @@ +if(!dojo._hasResource["dojo._base._loader.loader_xd"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base._loader.loader_xd"] = true; +//Cross-domain resource loader. +dojo.provide("dojo._base._loader.loader_xd"); + +dojo._xdReset = function(){ + //summary: Internal xd loader function. Resets the xd state. + + //This flag indicates where or not we have crossed into xdomain territory. Once any resource says + //it is cross domain, then the rest of the resources have to be treated as xdomain because we need + //to evaluate resources in order. If there is a xdomain resource followed by a xhr resource, we can't load + //the xhr resource until the one before it finishes loading. The text of the xhr resource will be converted + //to match the format for a xd resource and put in the xd load queue. + this._isXDomain = dojo.config.useXDomain || false; + + this._xdTimer = 0; + this._xdInFlight = {}; + this._xdOrderedReqs = []; + this._xdDepMap = {}; + this._xdContents = []; + this._xdDefList = []; +} + +//Call reset immediately to set the state. +dojo._xdReset(); + +dojo._xdCreateResource = function(/*String*/contents, /*String*/resourceName, /*String*/resourcePath){ + //summary: Internal xd loader function. Creates an xd module source given an + //non-xd module contents. + + //Remove comments. Not perfect, but good enough for dependency resolution. + var depContents = contents.replace(/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg , ""); + + //Find dependencies. + var deps = []; + var depRegExp = /dojo.(require|requireIf|provide|requireAfterIf|platformRequire|requireLocalization)\(([\w\W]*?)\)/mg; + var match; + while((match = depRegExp.exec(depContents)) != null){ + if(match[1] == "requireLocalization"){ + //Need to load the local bundles asap, since they are not + //part of the list of modules watched for loading. + eval(match[0]); + }else{ + deps.push('"' + match[1] + '", ' + match[2]); + } + } + + //Create resource object and the call to _xdResourceLoaded. + var output = []; + output.push(dojo._scopeName + "._xdResourceLoaded({\n"); + + //Add dependencies + if(deps.length > 0){ + output.push("depends: ["); + for(var i = 0; i < deps.length; i++){ + if(i > 0){ + output.push(",\n"); + } + output.push("[" + deps[i] + "]"); + } + output.push("],"); + } + + //Add the contents of the file inside a function. + //Pass in scope arguments so we can support multiple versions of the + //same module on a page. + output.push("\ndefineResource: function(" + dojo._scopePrefixArgs + "){"); + + //Don't put in the contents in the debugAtAllCosts case + //since the contents may have syntax errors. Let those + //get pushed up when the script tags are added to the page + //in the debugAtAllCosts case. + if(!dojo.config["debugAtAllCosts"] || resourceName == "dojo._base._loader.loader_debug"){ + output.push(contents); + } + //Add isLocal property so we know if we have to do something different + //in debugAtAllCosts situations. + output.push("\n}, resourceName: '" + resourceName + "', resourcePath: '" + resourcePath + "'});"); + + return output.join(""); //String +} + +dojo._xdIsXDomainPath = function(/*string*/relpath) { + //summary: Figure out whether the path is local or x-domain + //If there is a colon before the first / then, we have a URL with a protocol. + + var colonIndex = relpath.indexOf(":"); + var slashIndex = relpath.indexOf("/"); + + if(colonIndex > 0 && colonIndex < slashIndex){ + return true; + }else{ + //Is the base script URI-based URL a cross domain URL? + //If so, then the relpath will be evaluated relative to + //baseUrl, and therefore qualify as xdomain. + //Only treat it as xdomain if the page does not have a + //host (file:// url) or if the baseUrl does not match the + //current window's domain. + var url = this.baseUrl; + colonIndex = url.indexOf(":"); + slashIndex = url.indexOf("/"); + if(colonIndex > 0 && colonIndex < slashIndex && (!location.host || url.indexOf("http://" + location.host) != 0)){ + return true; + } + } + return false; +} + +dojo._loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){ + //summary: Internal xd loader function. Overrides loadPath() from loader.js. + //xd loading requires slightly different behavior from loadPath(). + + var currentIsXDomain = this._xdIsXDomainPath(relpath); + this._isXDomain |= currentIsXDomain; + + var uri = ((relpath.charAt(0) == '/' || relpath.match(/^\w+:/)) ? "" : this.baseUrl) + relpath; + + try{ + return ((!module || this._isXDomain) ? this._loadUri(uri, cb, currentIsXDomain, module) : this._loadUriAndCheck(uri, module, cb)); //Boolean + }catch(e){ + console.debug(e); + return false; //Boolean + } +} + +dojo._loadUri = function(/*String*/uri, /*Function?*/cb, /*boolean*/currentIsXDomain, /*String?*/module){ + //summary: Internal xd loader function. Overrides loadUri() from loader.js. + // xd loading requires slightly different behavior from loadPath(). + //description: Wanted to override getText(), but it is used by + // the widget code in too many, synchronous ways right now. + if(this._loadedUrls[uri]){ + return 1; //Boolean + } + + //Add the module (resource) to the list of modules. + //Only do this work if we have a modlue name. Otherwise, + //it is a non-xd i18n bundle, which can load immediately and does not + //need to be tracked. Also, don't track dojo.i18n, since it is a prerequisite + //and will be loaded correctly if we load it right away: it has no dependencies. + if(this._isXDomain && module && module != "dojo.i18n"){ + this._xdOrderedReqs.push(module); + + //Add to waiting resources if it is an xdomain resource. + //Don't add non-xdomain i18n bundles, those get evaled immediately. + if(currentIsXDomain || uri.indexOf("/nls/") == -1){ + this._xdInFlight[module] = true; + + //Increment inFlightCount + //This will stop the modulesLoaded from firing all the way. + this._inFlightCount++; + } + + //Start timer + if(!this._xdTimer){ + if(dojo.isAIR){ + this._xdTimer = setInterval(function(){dojo._xdWatchInFlight();}, 100); + }else{ + this._xdTimer = setInterval(dojo._scopeName + "._xdWatchInFlight();", 100); + } + } + this._xdStartTime = (new Date()).getTime(); + } + + if (currentIsXDomain){ + //Fix name to be a .xd.fileextension name. + var lastIndex = uri.lastIndexOf('.'); + if(lastIndex <= 0){ + lastIndex = uri.length - 1; + } + + var xdUri = uri.substring(0, lastIndex) + ".xd"; + if(lastIndex != uri.length - 1){ + xdUri += uri.substring(lastIndex, uri.length); + } + + if (dojo.isAIR){ + xdUri = xdUri.replace("app:/", "/"); + } + + //Add to script src + var element = document.createElement("script"); + element.type = "text/javascript"; + element.src = xdUri; + if(!this.headElement){ + this._headElement = document.getElementsByTagName("head")[0]; + + //Head element may not exist, particularly in html + //html 4 or tag soup cases where the page does not + //have a head tag in it. Use html element, since that will exist. + //Seems to be an issue mostly with Opera 9 and to lesser extent Safari 2 + if(!this._headElement){ + this._headElement = document.getElementsByTagName("html")[0]; + } + } + this._headElement.appendChild(element); + }else{ + var contents = this._getText(uri, null, true); + if(contents == null){ return 0; /*boolean*/} + + //If this is not xdomain, or if loading a i18n resource bundle, then send it down + //the normal eval/callback path. + if(this._isXDomain + && uri.indexOf("/nls/") == -1 + && module != "dojo.i18n"){ + var res = this._xdCreateResource(contents, module, uri); + dojo.eval(res); + }else{ + if(cb){ + contents = '('+contents+')'; + }else{ + //Only do the scoping if no callback. If a callback is specified, + //it is most likely the i18n bundle stuff. + contents = this._scopePrefix + contents + this._scopeSuffix; + } + var value = dojo["eval"](contents+"\r\n//@ sourceURL="+uri); + if(cb){ + cb(value); + } + } + } + + //These steps are done in the non-xd loader version of this function. + //Maintain these steps to fit in with the existing system. + this._loadedUrls[uri] = true; + this._loadedUrls.push(uri); + return true; //Boolean +} + +dojo._xdResourceLoaded = function(/*Object*/res){ + //summary: Internal xd loader function. Called by an xd module resource when + //it has been loaded via a script tag. + var deps = res.depends; + var requireList = null; + var requireAfterList = null; + var provideList = []; + if(deps && deps.length > 0){ + var dep = null; + var insertHint = 0; + var attachedResource = false; + for(var i = 0; i < deps.length; i++){ + dep = deps[i]; + + //Look for specific dependency indicators. + if (dep[0] == "provide"){ + provideList.push(dep[1]); + }else{ + if(!requireList){ + requireList = []; + } + if(!requireAfterList){ + requireAfterList = []; + } + + var unpackedDeps = this._xdUnpackDependency(dep); + if(unpackedDeps.requires){ + requireList = requireList.concat(unpackedDeps.requires); + } + if(unpackedDeps.requiresAfter){ + requireAfterList = requireAfterList.concat(unpackedDeps.requiresAfter); + } + } + + //Call the dependency indicator to allow for the normal dojo setup. + //Only allow for one dot reference, for the i18n._preloadLocalizations calls + //(and maybe future, one-dot things). + var depType = dep[0]; + var objPath = depType.split("."); + if(objPath.length == 2){ + dojo[objPath[0]][objPath[1]].apply(dojo[objPath[0]], dep.slice(1)); + }else{ + dojo[depType].apply(dojo, dep.slice(1)); + } + } + + + //If loading the debugAtAllCosts module, eval it right away since we need + //its functions to properly load the other modules. + if(provideList.length == 1 && provideList[0] == "dojo._base._loader.loader_debug"){ + res.defineResource(dojo); + }else{ + //Save off the resource contents for definition later. + var contentIndex = this._xdContents.push({ + content: res.defineResource, + resourceName: res["resourceName"], + resourcePath: res["resourcePath"], + isDefined: false + }) - 1; + + //Add provide/requires to dependency map. + for(var i = 0; i < provideList.length; i++){ + this._xdDepMap[provideList[i]] = { requires: requireList, requiresAfter: requireAfterList, contentIndex: contentIndex }; + } + } + + //Now update the inflight status for any provided resources in this loaded resource. + //Do this at the very end (in a *separate* for loop) to avoid shutting down the + //inflight timer check too soon. + for(var i = 0; i < provideList.length; i++){ + this._xdInFlight[provideList[i]] = false; + } + } +} + +dojo._xdLoadFlattenedBundle = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*Object*/bundleData){ + //summary: Internal xd loader function. Used when loading + //a flattened localized bundle via a script tag. + locale = locale || "root"; + var jsLoc = dojo.i18n.normalizeLocale(locale).replace('-', '_'); + var bundleResource = [moduleName, "nls", bundleName].join("."); + var bundle = dojo["provide"](bundleResource); + bundle[jsLoc] = bundleData; + + //Assign the bundle for the original locale(s) we wanted. + var mapName = [moduleName, jsLoc, bundleName].join("."); + var bundleMap = dojo._xdBundleMap[mapName]; + if(bundleMap){ + for(var param in bundleMap){ + bundle[param] = bundleData; + } + } +}; + + +dojo._xdInitExtraLocales = function(){ + // Simulate the extra locale work that dojo.requireLocalization does. + + var extra = dojo.config.extraLocale; + if(extra){ + if(!extra instanceof Array){ + extra = [extra]; + } + + dojo._xdReqLoc = dojo.xdRequireLocalization; + dojo.xdRequireLocalization = function(m, b, locale, fLocales){ + dojo._xdReqLoc(m,b,locale, fLocales); + if(locale){return;} + for(var i=0; i bestLocale.length){ + bestLocale = locales[i]; + } + } + } + + var fixedBestLocale = bestLocale.replace('-', '_'); + //See if the bundle we are going to use is already loaded. + var bundleResource = dojo.getObject([moduleName, "nls", bundleName].join(".")); + if(bundleResource && bundleResource[fixedBestLocale]){ + bundle[jsLoc.replace('-', '_')] = bundleResource[fixedBestLocale]; + }else{ + //Need to remember what locale we wanted and which one we actually use. + //Then when we load the one we are actually using, use that bundle for the one + //we originally wanted. + var mapName = [moduleName, (fixedBestLocale||"root"), bundleName].join("."); + var bundleMap = dojo._xdBundleMap[mapName]; + if(!bundleMap){ + bundleMap = dojo._xdBundleMap[mapName] = {}; + } + bundleMap[jsLoc.replace('-', '_')] = true; + + //Do just a normal dojo.require so the resource tracking stuff works as usual. + dojo.require(moduleName + ".nls" + (bestLocale ? "." + bestLocale : "") + "." + bundleName); + } +} + +// Replace dojo.requireLocalization with a wrapper +dojo._xdRealRequireLocalization = dojo.requireLocalization; +dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String*/availableFlatLocales){ + // summary: loads a bundle intelligently based on whether the module is + // local or xd. Overrides the local-case implementation. + + var modulePath = this.moduleUrl(moduleName).toString(); + if (this._xdIsXDomainPath(modulePath)) { + // call cross-domain loader + return dojo.xdRequireLocalization.apply(dojo, arguments); + } else { + // call local-loader + return dojo._xdRealRequireLocalization.apply(dojo, arguments); + } +} + +//This is a bit brittle: it has to know about the dojo methods that deal with dependencies +//It would be ideal to intercept the actual methods and do something fancy at that point, +//but I have concern about knowing which provide to match to the dependency in that case, +//since scripts can load whenever they want, and trigger new calls to dojo._xdResourceLoaded(). +dojo._xdUnpackDependency = function(/*Array*/dep){ + //summary: Internal xd loader function. Determines what to do with a dependency + //that was listed in an xd version of a module contents. + + //Extract the dependency(ies). + var newDeps = null; + var newAfterDeps = null; + switch(dep[0]){ + case "requireIf": + case "requireAfterIf": + //First arg (dep[1]) is the test. Depedency is dep[2]. + if(dep[1] === true){ + newDeps = [{name: dep[2], content: null}]; + } + break; + case "platformRequire": + var modMap = dep[1]; + var common = modMap["common"]||[]; + var newDeps = (modMap[dojo.hostenv.name_]) ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]); + //Flatten the array of arrays into a one-level deep array. + //Each result could be an array of 3 elements (the 3 arguments to dojo.require). + //We only need the first one. + if(newDeps){ + for(var i = 0; i < newDeps.length; i++){ + if(newDeps[i] instanceof Array){ + newDeps[i] = {name: newDeps[i][0], content: null}; + }else{ + newDeps[i] = {name: newDeps[i], content: null}; + } + } + } + break; + case "require": + //Just worry about dep[1] + newDeps = [{name: dep[1], content: null}]; + break; + case "i18n._preloadLocalizations": + //We can eval these immediately, since they load i18n bundles. + //Since i18n bundles have no dependencies, whenever they are loaded + //in a script tag, they are evaluated immediately, so we do not have to + //treat them has an explicit dependency for the dependency mapping. + //We can call it immediately since dojo.i18n is part of dojo.xd.js. + dojo.i18n._preloadLocalizations.apply(dojo.i18n._preloadLocalizations, dep.slice(1)); + break; + } + + //The requireIf and requireAfterIf needs to be evaluated after the current resource is evaluated. + if(dep[0] == "requireAfterIf" || dep[0] == "requireIf"){ + newAfterDeps = newDeps; + newDeps = null; + } + return {requires: newDeps, requiresAfter: newAfterDeps}; //Object +} + +dojo._xdWalkReqs = function(){ + //summary: Internal xd loader function. + //Walks the requires and evaluates module resource contents in + //the right order. + var reqChain = null; + var req; + for(var i = 0; i < this._xdOrderedReqs.length; i++){ + req = this._xdOrderedReqs[i]; + if(this._xdDepMap[req]){ + reqChain = [req]; + reqChain[req] = true; //Allow for fast lookup of the req in the array + this._xdEvalReqs(reqChain); + } + } +} + +dojo._xdEvalReqs = function(/*Array*/reqChain){ + //summary: Internal xd loader function. + //Does a depth first, breadth second search and eval of required modules. + while(reqChain.length > 0){ + var req = reqChain[reqChain.length - 1]; + var res = this._xdDepMap[req]; + if(res){ + //Trace down any requires for this resource. + //START dojo._xdTraceReqs() inlining for small Safari 2.0 call stack + var reqs = res.requires; + if(reqs && reqs.length > 0){ + var nextReq; + for(var i = 0; i < reqs.length; i++){ + nextReq = reqs[i].name; + if(nextReq && !reqChain[nextReq]){ + //New req depedency. Follow it down. + reqChain.push(nextReq); + reqChain[nextReq] = true; + this._xdEvalReqs(reqChain); + } + } + } + //END dojo._xdTraceReqs() inlining for small Safari 2.0 call stack + + //Evaluate the resource. + var contents = this._xdContents[res.contentIndex]; + if(!contents.isDefined){ + var content = contents.content; + content["resourceName"] = contents["resourceName"]; + content["resourcePath"] = contents["resourcePath"]; + this._xdDefList.push(content); + contents.isDefined = true; + } + this._xdDepMap[req] = null; + + //Trace down any requireAfters for this resource. + //START dojo._xdTraceReqs() inlining for small Safari 2.0 call stack + var reqs = res.requiresAfter; + if(reqs && reqs.length > 0){ + var nextReq; + for(var i = 0; i < reqs.length; i++){ + nextReq = reqs[i].name; + if(nextReq && !reqChain[nextReq]){ + //New req depedency. Follow it down. + reqChain.push(nextReq); + reqChain[nextReq] = true; + this._xdEvalReqs(reqChain); + } + } + } + //END dojo._xdTraceReqs() inlining for small Safari 2.0 call stack + } + + //Done with that require. Remove it and go to the next one. + reqChain.pop(); + } +} + +dojo._xdClearInterval = function(){ + //summary: Internal xd loader function. + //Clears the interval timer used to check on the + //status of in-flight xd module resource requests. + clearInterval(this._xdTimer); + this._xdTimer = 0; +} + +dojo._xdWatchInFlight = function(){ + //summary: Internal xd loader function. + //Monitors in-flight requests for xd module resources. + + var noLoads = ""; + var waitInterval = (dojo.config.xdWaitSeconds || 15) * 1000; + var expired = (this._xdStartTime + waitInterval) < (new Date()).getTime(); + + //If any xdInFlight are true, then still waiting for something to load. + //Come back later. If we timed out, report the things that did not load. + for(var param in this._xdInFlight){ + if(this._xdInFlight[param] === true){ + if(expired){ + noLoads += param + " "; + }else{ + return; + } + } + } + + //All done. Clean up and notify. + this._xdClearInterval(); + + if(expired){ + throw "Could not load cross-domain resources: " + noLoads; + } + + this._xdWalkReqs(); + + var defLength = this._xdDefList.length; + for(var i= 0; i < defLength; i++){ + var content = dojo._xdDefList[i]; + if(dojo.config["debugAtAllCosts"] && content["resourceName"]){ + if(!this["_xdDebugQueue"]){ + this._xdDebugQueue = []; + } + this._xdDebugQueue.push({resourceName: content.resourceName, resourcePath: content.resourcePath}); + }else{ + //Evaluate the resource to bring it into being. + //Pass in scope args to allow multiple versions of modules in a page. + content.apply(dojo.global, dojo._scopeArgs); + } + } + + //Evaluate any resources that were not evaled before. + //This normally shouldn't happen with proper dojo.provide and dojo.require + //usage, but providing it just in case. Note that these may not be executed + //in the original order that the developer intended. + for(var i = 0; i < this._xdContents.length; i++){ + var current = this._xdContents[i]; + if(current.content && !current.isDefined){ + //Pass in scope args to allow multiple versions of modules in a page. + current.content.apply(dojo.global, dojo._scopeArgs); + } + } + + //Clean up for the next round of xd loading. + this._xdReset(); + + if(this["_xdDebugQueue"] && this._xdDebugQueue.length > 0){ + this._xdDebugFileLoaded(); + }else{ + this._xdNotifyLoaded(); + } +} + +dojo._xdNotifyLoaded = function(){ + //Clear inflight count so we will finally do finish work. + this._inFlightCount = 0; + + //Only trigger call loaded if dj_load_init has run. + if(this._initFired && !this._loadNotifying){ + this._callLoaded(); + } +} + +} diff --git a/includes/js/dojo/_base/array.js b/includes/js/dojo/_base/array.js new file mode 100644 index 0000000..b0c68fa --- /dev/null +++ b/includes/js/dojo/_base/array.js @@ -0,0 +1,182 @@ +if(!dojo._hasResource["dojo._base.array"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.array"] = true; +dojo.require("dojo._base.lang"); +dojo.provide("dojo._base.array"); + +(function(){ + var _getParts = function(arr, obj, cb){ + return [ + dojo.isString(arr) ? arr.split("") : arr, + obj || dojo.global, + // FIXME: cache the anonymous functions we create here? + dojo.isString(cb) ? new Function("item", "index", "array", cb) : cb + ]; + }; + + dojo.mixin(dojo, { + indexOf: function( /*Array*/ array, + /*Object*/ value, + /*Integer?*/ fromIndex, + /*Boolean?*/ findLast){ + // summary: + // locates the first index of the provided value in the + // passed array. If the value is not found, -1 is returned. + // description: + // For details on this method, see: + // + + var step = 1, end = array.length || 0, i = 0; + if(findLast){ + i = end - 1; + step = end = -1; + } + if(fromIndex != undefined){ i = fromIndex; } + if((findLast && i > end) || i < end){ + for(; i != end; i += step){ + if(array[i] == value){ return i; } + } + } + return -1; // Number + }, + + lastIndexOf: function(/*Array*/array, /*Object*/value, /*Integer?*/fromIndex){ + // summary: + // locates the last index of the provided value in the passed array. + // If the value is not found, -1 is returned. + // description: + // For details on this method, see: + // + return dojo.indexOf(array, value, fromIndex, true); // Number + }, + + forEach: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){ + // summary: + // for every item in arr, callback is invoked. Return values are ignored. + // arr: the array to iterate on. 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. + // In environments that support JavaScript 1.6, this function is a passthrough to the built-in method. + // For more details, see: + // + + // match the behavior of the built-in forEach WRT empty arrs + if(!arr || !arr.length){ return; } + + // FIXME: there are several ways of handilng thisObject. Is + // dojo.global always the default context? + var _p = _getParts(arr, thisObject, callback); arr = _p[0]; + for(var i=0,l=_p[0].length; i + // example: + // | dojo.every([1, 2, 3, 4], function(item){ return item>1; }); + // returns false + // example: + // | dojo.every([1, 2, 3, 4], function(item){ return item>0; }); + // returns true + return this._everyOrSome(true, arr, callback, thisObject); // Boolean + }, + + some: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){ + // summary: + // Determines whether or not any item in arr satisfies the + // condition implemented by callback. + // arr: the array to iterate on. If a string, operates on individual characters. + // callback: a function is invoked with three arguments: item, index, and array and returns true + // if the condition is met. + // thisObject: may be used to scope the call to callback + // description: + // This function corresponds to the JavaScript 1.6 Array.some() method. + // In environments that support JavaScript 1.6, this function is a passthrough to the built-in method. + // For more details, see: + // + // example: + // | dojo.some([1, 2, 3, 4], function(item){ return item>1; }); + // returns true + // example: + // | dojo.some([1, 2, 3, 4], function(item){ return item<1; }); + // returns false + return this._everyOrSome(false, arr, callback, thisObject); // Boolean + }, + + map: function(/*Array|String*/arr, /*Function|String*/callback, /*Function?*/thisObject){ + // summary: + // applies callback to each element of arr and returns + // an Array with the results + // arr: the array to iterate on. If a string, operates on individual characters. + // callback: a function is invoked with three arguments: item, index, and array and returns a value + // thisObject: may be used to scope the call to callback + // description: + // This function corresponds to the JavaScript 1.6 Array.map() method. + // In environments that support JavaScript 1.6, this function is a passthrough to the built-in method. + // For more details, see: + // + // example: + // | dojo.map([1, 2, 3, 4], function(item){ return item+1 }); + // returns [2, 3, 4, 5] + var _p = _getParts(arr, thisObject, callback); arr = _p[0]; + var outArr = (arguments[3] ? (new arguments[3]()) : []); + for(var i=0;i + // example: + // | dojo.filter([1, 2, 3, 4], function(item){ return item>1; }); + // returns [2, 3, 4] + + var _p = _getParts(arr, thisObject, callback); arr = _p[0]; + var outArr = []; + for(var i = 0; i < arr.length; i++){ + if(_p[2].call(_p[1], arr[i], i, arr)){ + outArr.push(arr[i]); + } + } + return outArr; // Array + } + }); +})(); + +} diff --git a/includes/js/dojo/_base/browser.js b/includes/js/dojo/_base/browser.js new file mode 100644 index 0000000..9ee17a7 --- /dev/null +++ b/includes/js/dojo/_base/browser.js @@ -0,0 +1,21 @@ +if(!dojo._hasResource["dojo._base.browser"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.browser"] = true; +dojo.provide("dojo._base.browser"); + +dojo.require("dojo._base.window"); +dojo.require("dojo._base.event"); +dojo.require("dojo._base.html"); +dojo.require("dojo._base.NodeList"); +dojo.require("dojo._base.query"); +dojo.require("dojo._base.xhr"); +dojo.require("dojo._base.fx"); + +//Need this to be the last code segment in base, so do not place any +//dojo.requireIf calls in this file. Otherwise, due to how the build system +//puts all requireIf dependencies after the current file, the require calls +//could be called before all of base is defined. +if(dojo.config.require){ + dojo.forEach(dojo.config.require, "dojo['require'](item);"); +} + +} diff --git a/includes/js/dojo/_base/connect.js b/includes/js/dojo/_base/connect.js new file mode 100644 index 0000000..5111372 --- /dev/null +++ b/includes/js/dojo/_base/connect.js @@ -0,0 +1,285 @@ +if(!dojo._hasResource["dojo._base.connect"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.connect"] = true; +dojo.provide("dojo._base.connect"); +dojo.require("dojo._base.lang"); + +// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA + +// low-level delegation machinery +dojo._listener = { + // create a dispatcher function + getDispatcher: function(){ + // following comments pulled out-of-line to prevent cloning them + // in the returned function. + // - indices (i) that are really in the array of listeners (ls) will + // not be in Array.prototype. This is the 'sparse array' trick + // that keeps us safe from libs that take liberties with built-in + // objects + // - listener is invoked with current scope (this) + return function(){ + var ap=Array.prototype, c=arguments.callee, ls=c._listeners, t=c.target; + // return value comes from original target function + var r=t && t.apply(this, arguments); + // invoke listeners after target function + for(var i in ls){ + if(!(i in ap)){ + ls[i].apply(this, arguments); + } + } + // return value comes from original target function + return r; + } + }, + // add a listener to an object + add: function(/*Object*/ source, /*String*/ method, /*Function*/ listener){ + // Whenever 'method' is invoked, 'listener' will have the same scope. + // Trying to supporting a context object for the listener led to + // complexity. + // Non trivial to provide 'once' functionality here + // because listener could be the result of a dojo.hitch call, + // in which case two references to the same hitch target would not + // be equivalent. + source = source || dojo.global; + // The source method is either null, a dispatcher, or some other function + var f = source[method]; + // Ensure a dispatcher + if(!f||!f._listeners){ + var d = dojo._listener.getDispatcher(); + // original target function is special + d.target = f; + // dispatcher holds a list of listeners + d._listeners = []; + // redirect source to dispatcher + f = source[method] = d; + } + // The contract is that a handle is returned that can + // identify this listener for disconnect. + // + // The type of the handle is private. Here is it implemented as Integer. + // DOM event code has this same contract but handle is Function + // in non-IE browsers. + // + // We could have separate lists of before and after listeners. + return f._listeners.push(listener) ; /*Handle*/ + }, + // remove a listener from an object + remove: function(/*Object*/ source, /*String*/ method, /*Handle*/ handle){ + var f = (source||dojo.global)[method]; + // remember that handle is the index+1 (0 is not a valid handle) + if(f && f._listeners && handle--){ + delete f._listeners[handle]; + } + } +}; + +// Multiple delegation for arbitrary methods. + +// This unit knows nothing about DOM, +// but we include DOM aware +// documentation and dontFix +// argument here to help the autodocs. +// Actual DOM aware code is in event.js. + +dojo.connect = function(/*Object|null*/ obj, + /*String*/ event, + /*Object|null*/ context, + /*String|Function*/ method, + /*Boolean*/ dontFix){ + // summary: + // Create a link that calls one function when another executes. + // + // description: + // Connects method to event, so that after event fires, method + // does too. All connected functions are passed the same arguments as + // the event function was initially called with. You may connect as + // many methods to event as needed. + // + // event must be a string. If obj is null, dojo.global is used. + // + // null arguments may simply be omitted. + // + // obj[event] can resolve to a function or undefined (null). + // If obj[event] is null, it is assigned a function. + // + // The return value is a handle that is needed to + // remove this connection with dojo.disconnect. + // + // obj: + // The source object for the event function. + // Defaults to dojo.global if null. + // If obj is a DOM node, the connection is delegated + // to the DOM event manager (unless dontFix is true). + // + // event: + // String name of the event function in obj. + // I.e. identifies a property obj[event]. + // + // context: + // 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, + // dojo.global is used. + // + // method: + // 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: + // 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 + + // normalize arguments + var a=arguments, args=[], i=0; + // if a[0] is a String, obj was ommited + args.push(dojo.isString(a[0]) ? 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(dojo.isString(a1)||dojo.isFunction(a1) ? a[i++] : null, a[i++]); + // absorb any additional arguments + for(var l=a.length; i90)&&(k<96||k>111)&&(k<186||k>192)&&(k<219||k>222); + // 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; // 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 = del._punctMap[c] || c; // map other problematic CTRL combinations to ASCII + } + } + // simulate a keypress event + var faux = del._synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c}); + kp.call(evt.currentTarget, faux); + evt.cancelBubble = faux.cancelBubble; + evt.returnValue = faux.returnValue; + _trySetKeyCode(evt, faux.keyCode); + } + }, + // Called in Event scope + _stopPropagation: function(){ + this.cancelBubble = true; + }, + _preventDefault: function(){ + // Setting keyCode to 0 is the only way to prevent certain keypresses (namely + // ctrl-combinations that correspond to menu accelerator keys). + // Otoh, it prevents upstream listeners from getting this information + // Try to split the difference here by clobbering keyCode only for ctrl + // combinations. If you still need to access the key upstream, bubbledKeyCode is + // provided as a workaround. + this.bubbledKeyCode = this.keyCode; + if(this.ctrlKey){_trySetKeyCode(this, 0);} + this.returnValue = false; + } + }); + + // override stopEvent for IE + dojo.stopEvent = function(evt){ + evt = evt || window.event; + del._stopPropagation.call(evt); + del._preventDefault.call(evt); + } + } + + del._synthesizeEvent = function(evt, props){ + var faux = dojo.mixin({}, evt, props); + del._setKeyChar(faux); + // FIXME: would prefer to use dojo.hitch: dojo.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; + } + + // Opera event normalization + if(dojo.isOpera){ + dojo.mixin(del, { + _fixEvent: function(evt, sender){ + switch(evt.type){ + case "keypress": + 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<41)&&(!evt.shiftKey) ? 0 : c); + if((evt.ctrlKey)&&(!evt.shiftKey)&&(c>=65)&&(c<=90)){ + // lowercase CTRL-[A-Z] keys + c += 32; + } + return del._synthesizeEvent(evt, { charCode: c }); + } + return evt; + } + }); + } + + // Safari event normalization + if(dojo.isSafari){ + dojo.mixin(del, { + _fixEvent: function(evt, sender){ + switch(evt.type){ + case "keypress": + var c = evt.charCode, s = evt.shiftKey, k = evt.keyCode; + // FIXME: This is a hack, suggest we rethink keyboard strategy. + // Arrow and page keys have 0 "keyCode" in keypress events.on Safari for Windows + k = k || identifierMap[evt.keyIdentifier] || 0; + if(evt.keyIdentifier=="Enter"){ + c = 0; // differentiate Enter from CTRL-m (both code 13) + }else if((evt.ctrlKey)&&(c>0)&&(c<27)){ + c += 96; // map CTRL-[A-Z] codes to ASCII + } else if (c==dojo.keys.SHIFT_TAB) { + c = dojo.keys.TAB; // morph SHIFT_TAB into TAB + shiftKey: true + s = true; + } else { + c = (c>=32 && c<63232 ? c : 0); // avoid generating keyChar for non-printables + } + return del._synthesizeEvent(evt, {charCode: c, shiftKey: s, keyCode: k}); + } + return evt; + } + }); + + dojo.mixin(dojo.keys, { + SHIFT_TAB: 25, + UP_ARROW: 63232, + DOWN_ARROW: 63233, + LEFT_ARROW: 63234, + RIGHT_ARROW: 63235, + F1: 63236, + F2: 63237, + F3: 63238, + F4: 63239, + F5: 63240, + F6: 63241, + F7: 63242, + F8: 63243, + F9: 63244, + F10: 63245, + F11: 63246, + F12: 63247, + PAUSE: 63250, + DELETE: 63272, + HOME: 63273, + END: 63275, + PAGE_UP: 63276, + PAGE_DOWN: 63277, + INSERT: 63302, + PRINT_SCREEN: 63248, + SCROLL_LOCK: 63249, + NUM_LOCK: 63289 + }); + var dk = dojo.keys, identifierMap = { "Up": dk.UP_ARROW, "Down": dk.DOWN_ARROW, "Left": dk.LEFT_ARROW, "Right": dk.RIGHT_ARROW, "PageUp": dk.PAGE_UP, "PageDown": dk.PAGE_DOWN }; + } +})(); + +if(dojo.isIE){ + // keep this out of the closure + // closing over 'iel' or 'ieh' b0rks leak prevention + // ls[i] is an index into the master handler array + dojo._ieDispatcher = function(args, sender){ + var ap=Array.prototype, h=dojo._ie_listener.handlers, c=args.callee, ls=c._listeners, t=h[c.target]; + // return value comes from original target function + var r = t && t.apply(sender, args); + // invoke listeners after target function + for(var i in ls){ + if(!(i in ap)){ + h[ls[i]].apply(sender, args); + } + } + return r; + } + dojo._getIeDispatcher = function(){ + // ensure the returned function closes over nothing + return new Function(dojo._scopeName + "._ieDispatcher(arguments, this)"); // function + } + // keep this out of the closure to reduce RAM allocation + dojo._event_listener._fixCallback = function(fp){ + var f = dojo._event_listener._fixEvent; + return function(e){ return fp.call(this, f(e, this)); }; + } +} + +} diff --git a/includes/js/dojo/_base/fx.js b/includes/js/dojo/_base/fx.js new file mode 100644 index 0000000..33307a9 --- /dev/null +++ b/includes/js/dojo/_base/fx.js @@ -0,0 +1,584 @@ +if(!dojo._hasResource["dojo._base.fx"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.fx"] = true; +dojo.provide("dojo._base.fx"); +dojo.require("dojo._base.Color"); +dojo.require("dojo._base.connect"); +dojo.require("dojo._base.declare"); +dojo.require("dojo._base.lang"); +dojo.require("dojo._base.html"); + +/* + Animation losely package based on Dan Pupius' work, contributed under CLA: + http://pupius.co.uk/js/Toolkit.Drawing.js +*/ +(function(){ + + var d = dojo; + + 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; + this.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 + } + } + + d.declare("dojo._Animation", null, { + // summary + // 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. + constructor: function(/*Object*/ args){ + d.mixin(this, args); + if(d.isArray(this.curve)){ + /* curve: Array + pId: a */ + this.curve = new d._Line(this.curve[0], this.curve[1]); + } + }, + + // 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: rate/1000 = fps) + rate: 10 /* 100 fps */, + + /*===== + // delay: Integer + // The time in milliseconds to wait before starting animation after it has been .play()'ed + delay: null, + + // events + // + // 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, + + _fire: function(/*Event*/ evt, /*Array?*/ args){ + // summary: + // Convenience function. Fire event "evt" and pass it the + // arguments specified in "args". + // evt: + // The event to fire. + // args: + // The arguments to pass to the event. + try{ + if(this[evt]){ + this[evt].apply(this, args||[]); + } + }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. + var _t = this; + if(gotoStart){ + _t._stopTimer(); + _t._active = _t._paused = false; + _t._percent = 0; + }else if(_t._active && !_t._paused){ + return _t; // dojo._Animation + } + + _t._fire("beforeBegin"); + + var de = delay||_t.delay; + var _p = dojo.hitch(_t, "_play", gotoStart); + if(de > 0){ + setTimeout(_p, de); + return _t; // dojo._Animation + } + _p(); + return _t; + }, + + _play: function(gotoStart){ + var _t = this; + _t._startTime = new Date().valueOf(); + if(_t._paused){ + _t._startTime -= _t.duration * _t._percent; + } + _t._endTime = _t._startTime + _t.duration; + + _t._active = true; + _t._paused = false; + + var value = _t.curve.getValue(_t._percent); + 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. + this._stopTimer(); + if(!this._active){ return this; /*dojo._Animation*/ } + this._paused = true; + this._fire("onPause", [this.curve.getValue(this._percent)]); + return this; // 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. + this._stopTimer(); + this._active = this._paused = true; + this._percent = percent; + if(andPlay){ this.play(); } + return this; // dojo._Animation + }, + + stop: function(/*boolean?*/ gotoEnd){ + // summary: Stops a running animation. + // gotoEnd: If true, the animation will end. + if(!this._timer){ return this; /* dojo._Animation */ } + this._stopTimer(); + if(gotoEnd){ + this._percent = 1; + } + this._fire("onStop", [this.curve.getValue(this._percent)]); + this._active = this._paused = false; + return this; // 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._endTime - _t._startTime); + + 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._stopTimer(); + } + } + return _t; // dojo._Animation + } + }); + + var ctr = 0; + var _globalTimerList = []; + var runner = { + run: function(){ } + }; + var timer = null; + dojo._Animation.prototype._startTimer = function(){ + // this._timer = setTimeout(dojo.hitch(this, "_cycle"), this.rate); + if(!this._timer){ + this._timer = d.connect(runner, "run", this, "_cycle"); + ctr++; + } + if(!timer){ + timer = setInterval(d.hitch(runner, "run"), this.rate); + } + }; + + dojo._Animation.prototype._stopTimer = function(){ + if(this._timer){ + d.disconnect(this._timer); + this._timer = null; + ctr--; + } + if(ctr <= 0){ + clearInterval(timer); + timer = null; + ctr = 0; + } + }; + + var _makeFadeable = (d.isIE) ? function(node){ + // only set the zoom if the "tickle" value would be the same as the + // default + var ns = node.style; + if(!ns.zoom.length && d.style(node, "zoom") == "normal"){ + // make sure the node "hasLayout" + // NOTE: this has been tested with larger and smaller user-set text + // sizes and works fine + ns.zoom = "1"; + // node.style.zoom = "normal"; + } + // don't set the width to auto if it didn't already cascade that way. + // We don't want to f anyones designs + if(!ns.width.length && d.style(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 = d.byId(args.node); + var fArgs = d.mixin({ properties: {} }, args); + var props = (fArgs.properties.opacity = {}); + props.start = !("start" in fArgs) ? + function(){ + return Number(d.style(fArgs.node, "opacity")); + } : fArgs.start; + props.end = fArgs.end; + + var anim = d.animateProperty(fArgs); + d.connect(anim, "beforeBegin", d.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 d._fade(d.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 d._fade(d.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); + } + + 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 d.Color){ + // create a reusable temp color object to keep intermediate results + prop.tempColor = new d.Color(); + } + } + this.getValue = function(r){ + var ret = {}; + for(var p in this._properties){ + var prop = this._properties[p]; + var start = prop.start; + if(start instanceof d.Color){ + ret[p] = d.blendColors(start, prop.end, r, prop.tempColor).toCss(); + }else if(!d.isArray(start)){ + ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units||"px" : ""); + } + } + 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 'unit' 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 + // example: + // animate width, height, and padding over 2 seconds...the + // pedantic way: + // | dojo.animateProperty({ node: node, duration:2000, + // | properties: { + // | width: { start: '200', end: '400', unit:"px" }, + // | height: { start:'200', end: '400', unit:"px" }, + // | paddingTop: { start:'5', end:'50', unit:"px" } + // | } + // | }).play(); + // + // 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(){ + // | // called when the animation finishes + // | } + // | }).play(500); // delay playing half a second + + args.node = d.byId(args.node); + if(!args.easing){ args.easing = d._defaultEasing; } + + var anim = new d._Animation(args); + d.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]; + prop = pm[p] = d.mixin({}, (d.isObject(prop) ? prop: { end: prop })); + + if(d.isFunction(prop.start)){ + prop.start = prop.start(); + } + if(d.isFunction(prop.end)){ + prop.end = prop.end(); + } + 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 = d.style(node, p); + return (p=="opacity") ? Number(v) : (isColor ? v : parseFloat(v)); + } + if(!("end" in prop)){ + prop.end = getStyle(this.node, p); + }else if(!("start" in prop)){ + prop.start = getStyle(this.node, p); + } + + if(isColor){ + prop.start = new d.Color(prop.start); + prop.end = new d.Color(prop.end); + }else{ + prop.start = (p == "opacity") ? Number(prop.start) : parseFloat(prop.start); + } + } + this.curve = new PropLine(pm); + }); + d.connect(anim, "onAnimate", anim, function(propValues){ + // try{ + for(var s in propValues){ + d.style(this.node, s, propValues[s]); + // this.node.style[s] = propValues[s]; + } + }); + 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 `dojox.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 d.animateProperty({ + node: node, + duration: duration||d._Animation.prototype.duration, + properties: properties, + easing: easing, + onEnd: onEnd + }).play(delay||0); + } +})(); + +} diff --git a/includes/js/dojo/_base/html.js b/includes/js/dojo/_base/html.js new file mode 100644 index 0000000..d673eb1 --- /dev/null +++ b/includes/js/dojo/_base/html.js @@ -0,0 +1,1227 @@ +if(!dojo._hasResource["dojo._base.html"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.html"] = true; +dojo.require("dojo._base.lang"); +dojo.provide("dojo._base.html"); + +// FIXME: need to add unit tests for all the semi-public methods + +try{ + document.execCommand("BackgroundImageCache", false, true); +}catch(e){ + // sane browsers don't have cache "issues" +} + +// ============================= +// DOM Functions +// ============================= + +/*===== +dojo.byId = function(id, doc){ + // summary: + // Returns DOM node with matching `id` attribute or `null` + // if not found, similar to "$" function in another library. + // If `id` is a DomNode, this function is a no-op. + // + // id: String|DOMNode + // A string to match an HTML id attribute or a reference to a DOM Node + // + // doc: Document? + // Document to work in. Defaults to the current value of + // dojo.doc. Can be used to retrieve + // node references from other documents. +=====*/ +if(dojo.isIE || dojo.isOpera){ + dojo.byId = function(id, doc){ + if(dojo.isString(id)){ + var _d = doc || dojo.doc; + var te = _d.getElementById(id); + // attributes.id.value is better than just id in case the + // user has a name=id inside a form + if(te && te.attributes.id.value == id){ + return te; + }else{ + var eles = _d.all[id]; + if(!eles || !eles.length){ return eles; } + // if more than 1, choose first with the correct id + var i=0; + while((te=eles[i++])){ + if(te.attributes.id.value == id){ return te; } + } + } + }else{ + return id; // DomNode + } + } +}else{ + dojo.byId = function(id, doc){ + return dojo.isString(id) ? (doc || dojo.doc).getElementById(id) : id; // DomNode + } +} +/*===== +} +=====*/ + +(function(){ + /* + dojo.createElement = function(obj, parent, position){ + // TODO: need to finish this! + } + */ + + var d = dojo; + + var _destroyContainer = null; + dojo.addOnUnload(function(){ + _destroyContainer=null; //prevent IE leak + }); + dojo._destroyElement = function(/*String||DomNode*/node){ + // summary: + // removes node from its parent, clobbers it and all of its + // children. + // node: + // the element to be destroyed, either as an ID or a reference + + node = d.byId(node); + try{ + if(!_destroyContainer){ + _destroyContainer = document.createElement("div"); + } + _destroyContainer.appendChild(node.parentNode ? node.parentNode.removeChild(node) : node); + // NOTE: see http://trac.dojotoolkit.org/ticket/2931. This may be a bug and not a feature + _destroyContainer.innerHTML = ""; + }catch(e){ + /* squelch */ + } + }; + + dojo.isDescendant = function(/*DomNode|String*/node, /*DomNode|String*/ancestor){ + // summary: + // Returns true if node is a descendant of ancestor + // node: id or node reference to test + // ancestor: id or node reference of potential parent to test against + try{ + node = d.byId(node); + ancestor = d.byId(ancestor); + while(node){ + if(node === ancestor){ + return true; // Boolean + } + node = node.parentNode; + } + }catch(e){ /* squelch, return false */ } + return false; // Boolean + }; + + dojo.setSelectable = function(/*DomNode|String*/node, /*Boolean*/selectable){ + // summary: enable or disable selection on a node + // node: + // id or reference to node + // selectable: + node = d.byId(node); + if(d.isMozilla){ + node.style.MozUserSelect = selectable ? "" : "none"; + }else if(d.isKhtml){ + node.style.KhtmlUserSelect = selectable ? "auto" : "none"; + }else if(d.isIE){ + node.unselectable = selectable ? "" : "on"; + d.query("*", node).forEach(function(descendant){ + descendant.unselectable = selectable ? "" : "on"; + }); + } + //FIXME: else? Opera? + }; + + var _insertBefore = function(/*Node*/node, /*Node*/ref){ + ref.parentNode.insertBefore(node, ref); + return true; // boolean + } + + var _insertAfter = function(/*Node*/node, /*Node*/ref){ + // summary: + // Try to insert node after ref + var pn = ref.parentNode; + if(ref == pn.lastChild){ + pn.appendChild(node); + }else{ + return _insertBefore(node, ref.nextSibling); // boolean + } + return true; // boolean + } + + dojo.place = function(/*String|DomNode*/node, /*String|DomNode*/refNode, /*String|Number*/position){ + // summary: + // Attempt to insert node into the DOM, choosing from various positioning options. + // Returns true if successful, false otherwise. + // node: + // id or node reference to place relative to refNode + // refNode: + // id or node reference to use as basis for placement + // position: + // string noting the position of node relative to refNode or a + // number indicating the location in the childNodes collection of + // refNode. Accepted string values are: + // + // * before + // * after + // * first + // * last + // + // "first" and "last" indicate positions as children of refNode. + + // FIXME: need to write tests for this!!!! + if(!node || !refNode || position === undefined){ + return false; // boolean + } + node = d.byId(node); + refNode = d.byId(refNode); + if(typeof position == "number"){ + var cn = refNode.childNodes; + if((position == 0 && cn.length == 0) || + cn.length == position){ + refNode.appendChild(node); return true; + } + if(position == 0){ + return _insertBefore(node, refNode.firstChild); + } + return _insertAfter(node, cn[position-1]); + } + switch(position.toLowerCase()){ + case "before": + return _insertBefore(node, refNode); // boolean + case "after": + return _insertAfter(node, refNode); // boolean + case "first": + if(refNode.firstChild){ + return _insertBefore(node, refNode.firstChild); // boolean + } + // else fallthrough... + default: // aka: last + refNode.appendChild(node); + return true; // boolean + } + } + + // Box functions will assume this model. + // On IE/Opera, BORDER_BOX will be set if the primary document is in quirks mode. + // Can be set to change behavior of box setters. + + // can be either: + // "border-box" + // "content-box" (default) + dojo.boxModel = "content-box"; + + // We punt per-node box mode testing completely. + // If anybody cares, we can provide an additional (optional) unit + // that overrides existing code to include per-node box sensitivity. + + // Opera documentation claims that Opera 9 uses border-box in BackCompat mode. + // but experiments (Opera 9.10.8679 on Windows Vista) indicate that it actually continues to use content-box. + // IIRC, earlier versions of Opera did in fact use border-box. + // Opera guys, this is really confusing. Opera being broken in quirks mode is not our fault. + + if(d.isIE /*|| dojo.isOpera*/){ + var _dcm = document.compatMode; + // client code may have to adjust if compatMode varies across iframes + d.boxModel = _dcm == "BackCompat" || _dcm == "QuirksMode" || d.isIE<6 ? "border-box" : "content-box"; // FIXME: remove IE < 6 support? + } + + // ============================= + // Style Functions + // ============================= + + // getComputedStyle drives most of the style code. + // Wherever possible, reuse the returned object. + // + // API functions below that need to access computed styles accept an + // optional computedStyle parameter. + // If this parameter is omitted, the functions will call getComputedStyle themselves. + // This way, calling code can access computedStyle once, and then pass the reference to + // multiple API functions. + +/*===== + dojo.getComputedStyle = function(node){ + // summary: + // Returns a "computed style" object. + // + // description: + // Gets a "computed style" object which can be used to gather + // information about the current state of the rendered node. + // + // Note that this may behave differently on different browsers. + // Values may have different formats and value encodings across + // browsers. + // + // Note also that this method is expensive. Wherever possible, + // reuse the returned object. + // + // Use the dojo.style() method for more consistent (pixelized) + // return values. + // + // node: DOMNode + // A reference to a DOM node. Does NOT support taking an + // ID string for speed reasons. + // example: + // | dojo.getComputedStyle(dojo.byId('foo')).borderWidth; + return; // CSS2Properties + } +=====*/ + + var gcs, dv = document.defaultView; + if(d.isSafari){ + gcs = function(/*DomNode*/node){ + var s = dv.getComputedStyle(node, null); + if(!s && node.style){ + node.style.display = ""; + s = dv.getComputedStyle(node, null); + } + return s || {}; + }; + }else if(d.isIE){ + gcs = function(node){ + return node.currentStyle; + }; + }else{ + gcs = function(node){ + return dv.getComputedStyle(node, null); + }; + } + dojo.getComputedStyle = gcs; + + if(!d.isIE){ + dojo._toPixelValue = function(element, value){ + // style values can be floats, client code may want + // to round for integer pixels. + return parseFloat(value) || 0; + } + }else{ + dojo._toPixelValue = function(element, avalue){ + if(!avalue){ return 0; } + // on IE7, medium is usually 4 pixels + if(avalue=="medium"){ return 4; } + // style values can be floats, client code may + // want to round this value for integer pixels. + if(avalue.slice && (avalue.slice(-2)=='px')){ return parseFloat(avalue); } + with(element){ + var sLeft = style.left; + var rsLeft = runtimeStyle.left; + runtimeStyle.left = currentStyle.left; + try{ + // 'avalue' may be incompatible with style.left, which can cause IE to throw + // this has been observed for border widths using "thin", "medium", "thick" constants + // those particular constants could be trapped by a lookup + // but perhaps there are more + style.left = avalue; + avalue = style.pixelLeft; + }catch(e){ + avalue = 0; + } + style.left = sLeft; + runtimeStyle.left = rsLeft; + } + return avalue; + } + } + var px = d._toPixelValue; + + // FIXME: there opacity quirks on FF that we haven't ported over. Hrm. + /*===== + dojo._getOpacity = function(node){ + // summary: + // Returns the current opacity of the passed node as a + // floating-point value between 0 and 1. + // node: DomNode + // a reference to a DOM node. Does NOT support taking an + // ID string for speed reasons. + // return: Number between 0 and 1 + } + =====*/ + + dojo._getOpacity = d.isIE ? function(node){ + try{ + return node.filters.alpha.opacity / 100; // Number + }catch(e){ + return 1; // Number + } + } : function(node){ + return gcs(node).opacity; + }; + + /*===== + dojo._setOpacity = function(node, opacity){ + // summary: + // set the opacity of the passed node portably. Returns the + // new opacity of the node. + // node: DOMNode + // a reference to a DOM node. Does NOT support taking an + // ID string for performance reasons. + // opacity: Number + // A Number between 0 and 1. 0 specifies transparent. + // return: Number between 0 and 1 + } + =====*/ + + dojo._setOpacity = d.isIE ? function(/*DomNode*/node, /*Number*/opacity){ + if(opacity == 1){ + // on IE7 Alpha(Filter opacity=100) makes text look fuzzy so remove it altogether (bug #2661) + var filterRE = /FILTER:[^;]*;?/i; + node.style.cssText = node.style.cssText.replace(filterRE, ""); + if(node.nodeName.toLowerCase() == "tr"){ + d.query("> td", node).forEach(function(i){ + i.style.cssText = i.style.cssText.replace(filterRE, ""); + }); + } + }else{ + var o = "Alpha(Opacity="+ opacity * 100 +")"; + node.style.filter = o; + } + if(node.nodeName.toLowerCase() == "tr"){ + d.query("> td", node).forEach(function(i){ + i.style.filter = o; + }); + } + return opacity; + } : function(node, opacity){ + return node.style.opacity = opacity; + }; + + var _pixelNamesCache = { + left: true, top: true + }; + var _pixelRegExp = /margin|padding|width|height|max|min|offset/; // |border + var _toStyleValue = function(node, type, value){ + type = type.toLowerCase(); + if(d.isIE && value == "auto"){ + if(type == "height"){ return node.offsetHeight; } + if(type == "width"){ return node.offsetWidth; } + } + if(!(type in _pixelNamesCache)){ + // if(dojo.isOpera && type == "cssText"){ + // FIXME: add workaround for #2855 here + // } + _pixelNamesCache[type] = _pixelRegExp.test(type); + } + return _pixelNamesCache[type] ? px(node, value) : value; + } + + var _floatStyle = d.isIE ? "styleFloat" : "cssFloat"; + var _floatAliases = { "cssFloat": _floatStyle, "styleFloat": _floatStyle, "float": _floatStyle }; + + // public API + + dojo.style = function( /*DomNode|String*/ node, + /*String?|Object?*/ style, + /*String?*/ 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. + // node: + // id or reference to node to get/set style for + // style: + // 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: + // If passed, sets value on the node for style, handling + // cross-browser concerns. + // 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": 300 + // | }); + // + // 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" + // | }); + + var n = d.byId(node), args = arguments.length, op = (style=="opacity"); + style = _floatAliases[style] || style; + if(args == 3){ + return op ? d._setOpacity(n, value) : n.style[style] = value; /*Number*/ + } + if(args == 2 && op){ + return d._getOpacity(n); + } + var s = gcs(n); + if(args == 2 && !d.isString(style)){ + for(var x in style){ + d.style(node, x, style[x]); + } + return s; + } + return (args == 1) ? s : _toStyleValue(n, style, s[style]); /* CSS2Properties||String||Number */ + } + + // ============================= + // Box Functions + // ============================= + + dojo._getPadExtents = function(/*DomNode*/n, /*Object*/computedStyle){ + // summary: + // Returns object with special values specifically useful for node + // fitting. + // + // * l/t = left/top padding (respectively) + // * w = the total of the left and right padding + // * h = the total of the top and bottom padding + // + // If 'node' has position, l/t forms the origin for child nodes. + // The w/h are used for calculating boxes. + // Normally application code will not need to invoke this + // directly, and will use the ...box... functions instead. + var + s = computedStyle||gcs(n), + l = px(n, s.paddingLeft), + t = px(n, s.paddingTop); + return { + l: l, + t: t, + w: l+px(n, s.paddingRight), + h: t+px(n, s.paddingBottom) + }; + } + + dojo._getBorderExtents = function(/*DomNode*/n, /*Object*/computedStyle){ + // summary: + // returns an object with properties useful for noting the border + // dimensions. + // + // * l/t = the sum of left/top border (respectively) + // * w = the sum of the left and right border + // * h = the sum of the top and bottom border + // + // The w/h are used for calculating boxes. + // Normally application code will not need to invoke this + // directly, and will use the ...box... functions instead. + var + ne = "none", + s = computedStyle||gcs(n), + bl = (s.borderLeftStyle != ne ? px(n, s.borderLeftWidth) : 0), + bt = (s.borderTopStyle != ne ? px(n, s.borderTopWidth) : 0); + return { + l: bl, + t: bt, + w: bl + (s.borderRightStyle!=ne ? px(n, s.borderRightWidth) : 0), + h: bt + (s.borderBottomStyle!=ne ? px(n, s.borderBottomWidth) : 0) + }; + } + + dojo._getPadBorderExtents = function(/*DomNode*/n, /*Object*/computedStyle){ + // summary: + // returns object with properties useful for box fitting with + // regards to padding. + // + // * l/t = the sum of left/top padding and left/top border (respectively) + // * w = the sum of the left and right padding and border + // * h = the sum of the top and bottom padding and border + // + // The w/h are used for calculating boxes. + // Normally application code will not need to invoke this + // directly, and will use the ...box... functions instead. + var + s = computedStyle||gcs(n), + p = d._getPadExtents(n, s), + b = d._getBorderExtents(n, s); + return { + l: p.l + b.l, + t: p.t + b.t, + w: p.w + b.w, + h: p.h + b.h + }; + } + + dojo._getMarginExtents = function(n, computedStyle){ + // summary: + // returns object with properties useful for box fitting with + // regards to box margins (i.e., the outer-box). + // + // * l/t = marginLeft, marginTop, respectively + // * w = total width, margin inclusive + // * h = total height, margin inclusive + // + // The w/h are used for calculating boxes. + // Normally application code will not need to invoke this + // directly, and will use the ...box... functions instead. + var + s = computedStyle||gcs(n), + l = px(n, s.marginLeft), + t = px(n, s.marginTop), + r = px(n, s.marginRight), + b = px(n, s.marginBottom); + if(d.isSafari && (s.position != "absolute")){ + // FIXME: Safari's version of the computed right margin + // is the space between our right edge and the right edge + // of our offsetParent. + // What we are looking for is the actual margin value as + // determined by CSS. + // Hack solution is to assume left/right margins are the same. + r = l; + } + return { + l: l, + t: t, + w: l+r, + h: t+b + }; + } + + // Box getters work in any box context because offsetWidth/clientWidth + // are invariant wrt box context + // + // They do *not* work for display: inline objects that have padding styles + // because the user agent ignores padding (it's bogus styling in any case) + // + // Be careful with IMGs because they are inline or block depending on + // browser and browser mode. + + // Although it would be easier to read, there are not separate versions of + // _getMarginBox for each browser because: + // 1. the branching is not expensive + // 2. factoring the shared code wastes cycles (function call overhead) + // 3. duplicating the shared code wastes bytes + + dojo._getMarginBox = function(/*DomNode*/node, /*Object*/computedStyle){ + // summary: + // returns an object that encodes the width, height, left and top + // positions of the node's margin box. + var s = computedStyle||gcs(node), me = d._getMarginExtents(node, s); + var l = node.offsetLeft - me.l, t = node.offsetTop - me.t; + if(d.isMoz){ + // Mozilla: + // If offsetParent has a computed overflow != visible, the offsetLeft is decreased + // by the parent's border. + // We don't want to compute the parent's style, so instead we examine node's + // computed left/top which is more stable. + var sl = parseFloat(s.left), st = parseFloat(s.top); + if(!isNaN(sl) && !isNaN(st)){ + l = sl, t = st; + }else{ + // If child's computed left/top are not parseable as a number (e.g. "auto"), we + // have no choice but to examine the parent's computed style. + var p = node.parentNode; + if(p && p.style){ + var pcs = gcs(p); + if(pcs.overflow != "visible"){ + var be = d._getBorderExtents(p, pcs); + l += be.l, t += be.t; + } + } + } + }else if(d.isOpera){ + // On Opera, offsetLeft includes the parent's border + var p = node.parentNode; + if(p){ + var be = d._getBorderExtents(p); + l -= be.l, t -= be.t; + } + } + return { + l: l, + t: t, + w: node.offsetWidth + me.w, + h: node.offsetHeight + me.h + }; + } + + dojo._getContentBox = function(node, computedStyle){ + // summary: + // Returns an object that encodes the width, height, left and top + // positions of the node's content box, irrespective of the + // current box model. + + // clientWidth/Height are important since the automatically account for scrollbars + // fallback to offsetWidth/Height for special cases (see #3378) + var s=computedStyle||gcs(node), pe=d._getPadExtents(node, s), be=d._getBorderExtents(node, s), w=node.clientWidth, h; + if(!w){ + w=node.offsetWidth, h=node.offsetHeight; + }else{ + h=node.clientHeight, be.w = be.h = 0; + } + // On Opera, offsetLeft includes the parent's border + if(d.isOpera){ pe.l += be.l; pe.t += be.t; }; + return { + l: pe.l, + t: pe.t, + w: w - pe.w - be.w, + h: h - pe.h - be.h + }; + } + + dojo._getBorderBox = function(node, computedStyle){ + var s=computedStyle||gcs(node), pe=d._getPadExtents(node, s), cb=d._getContentBox(node, s); + return { + l: cb.l - pe.l, + t: cb.t - pe.t, + w: cb.w + pe.w, + h: cb.h + pe.h + }; + } + + // Box setters depend on box context because interpretation of width/height styles + // vary wrt box context. + // + // The value of dojo.boxModel is used to determine box context. + // dojo.boxModel can be set directly to change behavior. + // + // Beware of display: inline objects that have padding styles + // because the user agent ignores padding (it's a bogus setup anyway) + // + // Be careful with IMGs because they are inline or block depending on + // browser and browser mode. + // + // Elements other than DIV may have special quirks, like built-in + // margins or padding, or values not detectable via computedStyle. + // In particular, margins on TABLE do not seems to appear + // at all in computedStyle on Mozilla. + + dojo._setBox = function(/*DomNode*/node, /*Number?*/l, /*Number?*/t, /*Number?*/w, /*Number?*/h, /*String?*/u){ + // summary: + // sets width/height/left/top in the current (native) box-model + // dimentions. Uses the unit passed in u. + // node: DOM Node reference. Id string not supported for performance reasons. + // l: optional. left offset from parent. + // t: optional. top offset from parent. + // w: optional. width in current box model. + // h: optional. width in current box model. + // u: optional. unit measure to use for other measures. Defaults to "px". + u = u || "px"; + var s = node.style; + if(!isNaN(l)){ s.left = l+u; } + if(!isNaN(t)){ s.top = t+u; } + if(w>=0){ s.width = w+u; } + if(h>=0){ s.height = h+u; } + } + + dojo._usesBorderBox = function(/*DomNode*/node){ + // summary: + // True if the node uses border-box layout. + + // We could test the computed style of node to see if a particular box + // has been specified, but there are details and we choose not to bother. + var n = node.tagName; + // For whatever reason, TABLE and BUTTON are always border-box by default. + // If you have assigned a different box to either one via CSS then + // box functions will break. + return d.boxModel=="border-box" || n=="TABLE" || n=="BUTTON"; // boolean + } + + dojo._setContentSize = function(/*DomNode*/node, /*Number*/widthPx, /*Number*/heightPx, /*Object*/computedStyle){ + // summary: + // Sets the size of the node's contents, irrespective of margins, + // padding, or borders. + if(d._usesBorderBox(node)){ + var pb = d._getPadBorderExtents(node, computedStyle); + if(widthPx >= 0){ widthPx += pb.w; } + if(heightPx >= 0){ heightPx += pb.h; } + } + d._setBox(node, NaN, NaN, widthPx, heightPx); + } + + dojo._setMarginBox = function(/*DomNode*/node, /*Number?*/leftPx, /*Number?*/topPx, + /*Number?*/widthPx, /*Number?*/heightPx, + /*Object*/computedStyle){ + // summary: + // sets the size of the node's margin box and placement + // (left/top), irrespective of box model. Think of it as a + // passthrough to dojo._setBox that handles box-model vagaries for + // you. + + var s = computedStyle||gcs(node); + // Some elements have special padding, margin, and box-model settings. + // To use box functions you may need to set padding, margin explicitly. + // Controlling box-model is harder, in a pinch you might set dojo.boxModel. + var bb=d._usesBorderBox(node), + pb=bb ? _nilExtents : d._getPadBorderExtents(node, s), + mb=d._getMarginExtents(node, s); + if(widthPx>=0){ widthPx = Math.max(widthPx - pb.w - mb.w, 0); } + if(heightPx>=0){ heightPx = Math.max(heightPx - pb.h - mb.h, 0); } + d._setBox(node, leftPx, topPx, widthPx, heightPx); + } + + var _nilExtents = { l:0, t:0, w:0, h:0 }; + + // public API + + dojo.marginBox = function(/*DomNode|String*/node, /*Object?*/box){ + // summary: + // Getter/setter for the margin-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 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. + var n=d.byId(node), s=gcs(n), b=box; + return !b ? d._getMarginBox(n, s) : d._setMarginBox(n, b.l, b.t, b.w, b.h, s); // Object + } + + dojo.contentBox = function(/*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. + // 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. All properties are optional if passed. + var n=dojo.byId(node), s=gcs(n), b=box; + return !b ? d._getContentBox(n, s) : d._setContentSize(n, b.w, b.h, s); // Object + } + + // ============================= + // Positioning + // ============================= + + var _sumAncestorProperties = function(node, prop){ + if(!(node = (node||0).parentNode)){return 0}; + var val, retVal = 0, _b = d.body(); + while(node && node.style){ + if(gcs(node).position == "fixed"){ + return 0; + } + val = node[prop]; + if(val){ + retVal += val - 0; + // opera and khtml #body & #html has the same values, we only + // need one value + if(node == _b){ break; } + } + node = node.parentNode; + } + return retVal; // integer + } + + dojo._docScroll = function(){ + var + _b = d.body(), + _w = d.global, + de = d.doc.documentElement; + return { + y: (_w.pageYOffset || de.scrollTop || _b.scrollTop || 0), + x: (_w.pageXOffset || d._fixIeBiDiScrollLeft(de.scrollLeft) || _b.scrollLeft || 0) + }; + }; + + dojo._isBodyLtr = function(){ + //FIXME: could check html and body tags directly instead of computed style? need to ignore case, accept empty values + return !("_bodyLtr" in d) ? + d._bodyLtr = gcs(d.body()).direction == "ltr" : + d._bodyLtr; // Boolean + } + + dojo._getIeDocumentElementOffset = function(){ + // summary + // The following values in IE contain an offset: + // event.clientX + // event.clientY + // node.getBoundingClientRect().left + // node.getBoundingClientRect().top + // But other position related values do not contain this offset, such as + // node.offsetLeft, node.offsetTop, node.style.left and node.style.top. + // The offset is always (2, 2) in LTR direction. When the body is in RTL + // direction, the offset counts the width of left scroll bar's width. + // This function computes the actual offset. + + //NOTE: assumes we're being called in an IE browser + + var de = d.doc.documentElement; + //FIXME: use this instead? var de = d.compatMode == "BackCompat" ? d.body : d.documentElement; + + return (d.isIE >= 7) ? + {x: de.getBoundingClientRect().left, y: de.getBoundingClientRect().top} + : + // IE 6.0 + {x: d._isBodyLtr() || window.parent == window ? + de.clientLeft : de.offsetWidth - de.clientWidth - de.clientLeft, + y: de.clientTop}; // Object + }; + + dojo._fixIeBiDiScrollLeft = function(/*Integer*/ scrollLeft){ + // In RTL direction, scrollLeft should be a negative value, but IE + // returns a positive one. All codes using documentElement.scrollLeft + // must call this function to fix this error, otherwise the position + // will offset to right when there is a horizontal scrollbar. + var dd = d.doc; + if(d.isIE && !dojo._isBodyLtr()){ + var de = dd.compatMode == "BackCompat" ? dd.body : dd.documentElement; + return scrollLeft + de.clientWidth - de.scrollWidth; // Integer + } + return scrollLeft; // Integer + } + + dojo._abs = function(/*DomNode*/node, /*Boolean?*/includeScroll){ + // summary: + // Gets the position of the passed element relative to + // the viewport (if includeScroll==false), or relative to the + // document root (if includeScroll==true). + // + // Returns an object of the form: + // { x: 100, y: 300 } + // if includeScroll is passed, the x and y values will include any + // document offsets that may affect the position relative to the + // viewport. + + // FIXME: need to decide in the brave-new-world if we're going to be + // margin-box or border-box. + var ownerDocument = node.ownerDocument; + var ret = { + x: 0, + y: 0 + }; + + // targetBoxType == "border-box" + var db = d.body(); + if(d.isIE || (d.isFF >= 3)){ + var client = node.getBoundingClientRect(); + var offset = (d.isIE) ? d._getIeDocumentElementOffset() : { x: 0, y: 0}; + ret.x = client.left - offset.x; + ret.y = client.top - offset.y; + }else if(ownerDocument["getBoxObjectFor"]){ + // mozilla + var bo = ownerDocument.getBoxObjectFor(node), + b = d._getBorderExtents(node); + ret.x = bo.x - b.l - _sumAncestorProperties(node, "scrollLeft"); + ret.y = bo.y - b.t - _sumAncestorProperties(node, "scrollTop"); + }else{ + if(node["offsetParent"]){ + var endNode; + // in Safari, if the node is an absolutely positioned child of + // the body and the body has a margin the offset of the child + // and the body contain the body's margins, so we need to end + // at the body + // FIXME: getting contrary results to the above in latest WebKit. + if(d.isSafari && + //(node.style.getPropertyValue("position") == "absolute") && + (gcs(node).position == "absolute") && + (node.parentNode == db)){ + endNode = db; + }else{ + endNode = db.parentNode; + } + if(node.parentNode != db){ + var nd = node; + if(d.isOpera){ nd = db; } + ret.x -= _sumAncestorProperties(nd, "scrollLeft"); + ret.y -= _sumAncestorProperties(nd, "scrollTop"); + } + var curnode = node; + do{ + var n = curnode.offsetLeft; + //FIXME: ugly hack to workaround the submenu in + //popupmenu2 does not shown up correctly in opera. + //Someone have a better workaround? + if(!d.isOpera || n > 0){ + ret.x += isNaN(n) ? 0 : n; + } + var t = curnode.offsetTop; + ret.y += isNaN(t) ? 0 : t; + if(d.isSafari && curnode != node){ + var cs = gcs(curnode); + ret.x += px(curnode, cs.borderLeftWidth); + ret.y += px(curnode, cs.borderTopWidth); + } + curnode = curnode.offsetParent; + }while((curnode != endNode) && curnode); + }else if(node.x && node.y){ + ret.x += isNaN(node.x) ? 0 : node.x; + ret.y += isNaN(node.y) ? 0 : node.y; + } + } + // account for document scrolling + // if offsetParent is used, ret value already includes scroll position + // so we may have to actually remove that value if !includeScroll + if(includeScroll){ + var scroll = d._docScroll(); + ret.y += scroll.y; + ret.x += scroll.x; + } + + return ret; // object + } + + // FIXME: need a setter for coords or a moveTo!! + dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){ + // summary: + // Returns an object that measures margin box width/height and + // absolute positioning data from dojo._abs(). + // + // description: + // Returns an object that measures margin box width/height and + // absolute positioning data from dojo._abs(). + // 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._abs(). + var n=d.byId(node), s=gcs(n), mb=d._getMarginBox(n, s); + var abs = d._abs(n, includeScroll); + mb.x = abs.x; + mb.y = abs.y; + return mb; + } + + // ============================= + // Element attribute Functions + // ============================= + + var _fixAttrName = function(/*String*/name){ + switch(name.toLowerCase()){ + case "tabindex": + // Internet Explorer will only set or remove tabindex + // if it is spelled "tabIndex" + // console.debug((dojo.isIE && dojo.isIE < 8)? "tabIndex" : "tabindex"); + return (d.isIE && d.isIE < 8) ? "tabIndex" : "tabindex"; + default: + return name; + } + } + + // non-deprecated HTML4 attributes with default values + // http://www.w3.org/TR/html401/index/attributes.html + // FF and Safari will return the default values if you + // access the attributes via a property but not + // via getAttribute() + var _attrProps = { + colspan: "colSpan", + enctype: "enctype", + frameborder: "frameborder", + method: "method", + rowspan: "rowSpan", + scrolling: "scrolling", + shape: "shape", + span: "span", + type: "type", + valuetype: "valueType" + } + + dojo.hasAttr = function(/*DomNode|String*/node, /*String*/name){ + // summary: + // Returns true if the requested attribute is specified on the + // given element, and false otherwise. + // node: + // id or reference to the element to check + // name: + // the name of the attribute + // returns: + // true if the requested attribute is specified on the + // given element, and false otherwise + var attr = d.byId(node).getAttributeNode(_fixAttrName(name)); + return attr ? attr.specified : false; // Boolean + } + + var _evtHdlrMap = { + + } + + var _ctr = 0; + var _attrId = dojo._scopeName + "attrid"; + + dojo.attr = function(/*DomNode|String*/node, /*String|Object*/name, /*String?*/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 argumnt is a + // string, acts as a getter. + // + // If a third argument is passed, or if the second argumnt 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 attribute on + // name: + // the name of the attribute to get or set. + // value: + // 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 user as a setter, undefined + // example: + // | // get the current value of the "foo" attribute on a node + // | dojo.attr(dojo.byId("nodeId"), "foo"); + // | + // | // we can just pass the id: + // | dojo.attr("nodeId", "foo"); + // | + // | // use attr() to set the tab index + // | dojo.attr("nodeId", "tabindex", 3); + // | + // | // 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" }); + // | } + // | }); + + var args = arguments.length; + if(args == 2 && !d.isString(name)){ + for(var x in name){ d.attr(node, x, name[x]); } + return; + } + node = d.byId(node); + name = _fixAttrName(name); + if(args == 3){ + if(d.isFunction(value)){ + // clobber if we can + var attrId = d.attr(node, _attrId); + if(!attrId){ + attrId = _ctr++; + d.attr(node, _attrId, attrId); + } + if(!_evtHdlrMap[attrId]){ + _evtHdlrMap[attrId] = {}; + } + var h = _evtHdlrMap[attrId][name]; + if(h){ + d.disconnect(h); + }else{ + try{ + delete node[name]; + }catch(e){} + } + + // ensure that event objects are normalized, etc. + _evtHdlrMap[attrId][name] = d.connect(node, name, value); + + }else if(typeof value == "boolean"){ // e.g. onsubmit, disabled + // if a function, we should normalize the event object here!!! + node[name] = value; + }else{ + node.setAttribute(name, value); + } + return; + }else{ + // should we access this attribute via a property or + // via getAttribute()? + var prop = _attrProps[name.toLowerCase()]; + if(prop){ + return node[prop]; + }else{ + var value = node[name]; + return (typeof value == 'boolean' || typeof value == 'function') ? value : (d.hasAttr(node, name) ? node.getAttribute(name) : null); + } + } + } + + dojo.removeAttr = function(/*DomNode|String*/node, /*String*/name){ + // summary: + // Removes an attribute from an HTML element. + // node: + // id or reference to the element to remove the attribute from + // name: + // the name of the attribute to remove + d.byId(node).removeAttribute(_fixAttrName(name)); + } +})(); + +// ============================= +// (CSS) Class Functions +// ============================= + +dojo.hasClass = function(/*DomNode|String*/node, /*String*/classStr){ + // summary: + // Returns whether or not the specified classes are a portion of the + // class list currently applied to the node. + return ((" "+dojo.byId(node).className+" ").indexOf(" "+classStr+" ") >= 0); // Boolean +}; + +dojo.addClass = function(/*DomNode|String*/node, /*String*/classStr){ + // summary: + // Adds the specified classes to the end of the class list on the + // passed node. + node = dojo.byId(node); + var cls = node.className; + if((" "+cls+" ").indexOf(" "+classStr+" ") < 0){ + node.className = cls + (cls ? ' ' : '') + classStr; + } +}; + +dojo.removeClass = function(/*DomNode|String*/node, /*String*/classStr){ + // summary: Removes the specified classes from node. + node = dojo.byId(node); + var t = dojo.trim((" " + node.className + " ").replace(" " + classStr + " ", " ")); + if(node.className != t){ node.className = t; } +}; + +dojo.toggleClass = function(/*DomNode|String*/node, /*String*/classStr, /*Boolean?*/condition){ + // summary: + // Adds a class to node if not present, or removes if present. + // Pass a boolean condition if you want to explicitly add or remove. + // condition: + // If passed, true means to add the class, false means to remove. + if(condition === undefined){ + condition = !dojo.hasClass(node, classStr); + } + dojo[condition ? "addClass" : "removeClass"](node, classStr); +}; + +} diff --git a/includes/js/dojo/_base/json.js b/includes/js/dojo/_base/json.js new file mode 100644 index 0000000..55d8035 --- /dev/null +++ b/includes/js/dojo/_base/json.js @@ -0,0 +1,137 @@ +if(!dojo._hasResource["dojo._base.json"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.json"] = true; +dojo.provide("dojo._base.json"); + +dojo.fromJson = function(/*String*/ json){ + // summary: + // Parses a [JSON](http://json.org) string to return a JavaScript object. + // json: + // a string literal of a JSON item, for instance: + // `'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'` + + return eval("(" + json + ")"); // Object +} + +dojo._escapeString = function(/*String*/str){ + //summary: + // Adds escape sequences for non-visual characters, double quote and + // backslash and surrounds with double quotes to form a valid string + // literal. + return ('"' + str.replace(/(["\\])/g, '\\$1') + '"'). + replace(/[\f]/g, "\\f").replace(/[\b]/g, "\\b").replace(/[\n]/g, "\\n"). + replace(/[\t]/g, "\\t").replace(/[\r]/g, "\\r"); // string +} + +dojo.toJsonIndentStr = "\t"; +dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint, /*String?*/ _indentStr){ + // 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: + // 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. + // + // 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(). + // + // _indentStr: + // private variable for recursive calls when pretty printing, do not use. + + if(it === undefined){ + return "undefined"; + } + var objtype = typeof it; + if(objtype == "number" || objtype == "boolean"){ + return it + ""; + } + if(it === null){ + return "null"; + } + if(dojo.isString(it)){ + return dojo._escapeString(it); + } + if(it.nodeType && it.cloneNode){ // isNode + return ""; // FIXME: would something like outerHTML be better here? + } + // recurse + var recurse = arguments.callee; + // short-circuit for objects that support "json" serialization + // if they return "self" then just pass-through... + var newObj; + _indentStr = _indentStr || ""; + var nextIndent = prettyPrint ? _indentStr + dojo.toJsonIndentStr : ""; + if(typeof it.__json__ == "function"){ + newObj = it.__json__(); + if(it !== newObj){ + return recurse(newObj, prettyPrint, nextIndent); + } + } + if(typeof it.json == "function"){ + newObj = it.json(); + if(it !== newObj){ + return recurse(newObj, prettyPrint, nextIndent); + } + } + + var sep = prettyPrint ? " " : ""; + var newLine = prettyPrint ? "\n" : ""; + + // array + if(dojo.isArray(it)){ + var res = dojo.map(it, function(obj){ + var val = recurse(obj, prettyPrint, nextIndent); + if(typeof val != "string"){ + val = "undefined"; + } + return newLine + nextIndent + val; + }); + return "[" + res.join("," + sep) + newLine + _indentStr + "]"; + } + /* + // look in the registry + try { + window.o = it; + newObj = dojo.json.jsonRegistry.match(it); + return recurse(newObj, prettyPrint, nextIndent); + }catch(e){ + // console.debug(e); + } + // it's a function with no adapter, skip it + */ + if(objtype == "function"){ + return null; // null + } + // generic object code path + var output = []; + for(var key in it){ + var keyStr; + if(typeof key == "number"){ + keyStr = '"' + key + '"'; + }else if(typeof key == "string"){ + keyStr = dojo._escapeString(key); + }else{ + // skip non-string or number keys + continue; + } + val = recurse(it[key], prettyPrint, nextIndent); + if(typeof val != "string"){ + // skip non-serializable values + continue; + } + // FIXME: use += on Moz!! + // MOW NOTE: using += is a pain because you have to account for the dangling comma... + output.push(newLine + nextIndent + keyStr + ":" + sep + val); + } + return "{" + output.join("," + sep) + newLine + _indentStr + "}"; // String +} + +} diff --git a/includes/js/dojo/_base/lang.js b/includes/js/dojo/_base/lang.js new file mode 100644 index 0000000..feedc21 --- /dev/null +++ b/includes/js/dojo/_base/lang.js @@ -0,0 +1,257 @@ +if(!dojo._hasResource["dojo._base.lang"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.lang"] = true; +dojo.provide("dojo._base.lang"); + +// Crockford (ish) functions + +dojo.isString = function(/*anything*/ it){ + // summary: + // Return true if it is a String + return !!arguments.length && it != null && (typeof it == "string" || it instanceof String); // Boolean +} + +dojo.isArray = function(/*anything*/ it){ + // summary: + // Return true if it is an Array + return it && (it instanceof Array || typeof it == "array"); // Boolean +} + +/*===== +dojo.isFunction = function(it){ + // summary: Return true if it is a Function + // it: anything + // return: Boolean +} +=====*/ + +dojo.isFunction = (function(){ + var _isFunction = function(/*anything*/ it){ + return it && (typeof it == "function" || it instanceof Function); // Boolean + }; + + return dojo.isSafari ? + // only slow this down w/ gratuitious casting in Safari since it's what's b0rken + function(/*anything*/ it){ + if(typeof it == "function" && it == "[object NodeList]"){ return false; } + return _isFunction(it); // Boolean + } : _isFunction; +})(); + +dojo.isObject = function(/*anything*/ it){ + // summary: + // Returns true if it is a JavaScript object (or an Array, a Function + // or null) + return it !== undefined && + (it === null || typeof it == "object" || dojo.isArray(it) || dojo.isFunction(it)); // Boolean +} + +dojo.isArrayLike = function(/*anything*/ it){ + // summary: + // similar to dojo.isArray() but more permissive + // 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(). + // return: + // If it walks like a duck and quicks like a duck, return `true` + var d = dojo; + return it && it !== undefined && + // keep out built-in constructors (Number, String, ...) which have length + // properties + !d.isString(it) && !d.isFunction(it) && + !(it.tagName && it.tagName.toLowerCase() == 'form') && + (d.isArray(it) || isFinite(it.length)); // Boolean +} + +dojo.isAlien = function(/*anything*/ 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 + return it && !dojo.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean +} + +dojo.extend = function(/*Object*/ constructor, /*Object...*/ props){ + // summary: + // Adds all properties and methods of props to constructor's + // prototype, making them available to all instances created with + // constructor. + for(var i=1, l=arguments.length; i 2){ + return dojo._hitchArgs.apply(dojo, arguments); // Function + } + if(!method){ + method = scope; + scope = null; + } + if(dojo.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 +} + +/*===== +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: + // The object to delegate to for properties not found directly on the + // return object or in props. + // props: + // 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.delegate = dojo._delegate = function(obj, props){ + + // boodman/crockford delegation + function TMP(){}; + TMP.prototype = obj; + var tmp = new TMP(); + if(props){ + dojo.mixin(tmp, props); + } + return tmp; // Object +} + +dojo.partial = function(/*Function|String*/method /*, ...*/){ + // summary: + // similar to hitch() except that the scope object is left to be + // whatever the execution context eventually becomes. + // description: + // Calling dojo.partial is the functional equivalent of calling: + // | dojo.hitch(null, funcName, ...); + var arr = [ null ]; + return dojo.hitch.apply(dojo, arr.concat(dojo._toArray(arguments))); // Function +} + +dojo._toArray = function(/*Object*/obj, /*Number?*/offset, /*Array?*/ startWith){ + // summary: + // Converts an array-like object (i.e. arguments, DOMCollection) to an + // array. Returns a new Array with the elements of obj. + // obj: + // the object to "arrayify". We expect the object to have, at a + // minimum, a length property which corresponds to integer-indexed + // properties. + // offset: + // the location in obj to start iterating from. Defaults to 0. + // Optional. + // startWith: + // 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. + var arr = startWith||[]; + for(var x = offset || 0; x < obj.length; x++){ + arr.push(obj[x]); + } + return arr; // Array +} + +dojo.clone = function(/*anything*/ o){ + // summary: + // Clones objects (including DOM nodes) and all children. + // Warning: do not clone cyclic structures. + if(!o){ return o; } + if(dojo.isArray(o)){ + var r = []; + for(var i = 0; i < o.length; ++i){ + r.push(dojo.clone(o[i])); + } + return r; // Array + } + if(!dojo.isObject(o)){ + return o; /*anything*/ + } + if(o.nodeType && o.cloneNode){ // isNode + return o.cloneNode(true); // Node + } + if(o instanceof Date){ + return new Date(o.getTime()); // Date + } + // Generic objects + var r = new o.constructor(); // specific to dojo.declare()'d classes! + for(var i in o){ + if(!(i in r) || r[i] != o[i]){ + r[i] = dojo.clone(o[i]); + } + } + return r; // Object +} + +dojo.trim = function(/*String*/ str){ + // summary: + // trims whitespaces from both sides of the 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). + // The fastest but longest version of this function is located at + // dojo.string.trim() + return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // String +} + +} diff --git a/includes/js/dojo/_base/query.js b/includes/js/dojo/_base/query.js new file mode 100644 index 0000000..8743df8 --- /dev/null +++ b/includes/js/dojo/_base/query.js @@ -0,0 +1,1191 @@ +if(!dojo._hasResource["dojo._base.query"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.query"] = true; +dojo.provide("dojo._base.query"); +dojo.require("dojo._base.NodeList"); + +/* + dojo.query() architectural overview: + + dojo.query is a relatively full-featured CSS3 query library. It is + designed to take any valid CSS3 selector and return the nodes matching + the selector. To do this quickly, it processes queries in several + steps, applying caching where profitable. + + The steps (roughly in reverse order of the way they appear in the code): + 1.) check to see if we already have a "query dispatcher" + - if so, use that with the given parameterization. Skip to step 4. + 2.) attempt to determine which branch to dispatch the query to: + - JS (optimized DOM iteration) + - xpath (for browsers that support it and where it's fast) + - native (not available in any browser yet) + 3.) tokenize and convert to executable "query dispatcher" + - this is where the lion's share of the complexity in the + system lies. In the DOM version, the query dispatcher is + assembled as a chain of "yes/no" test functions pertaining to + a section of a simple query statement (".blah:nth-child(odd)" + but not "div div", which is 2 simple statements). Individual + statement dispatchers are cached (to prevent re-definition) + as are entire dispatch chains (to make re-execution of the + same query fast) + - in the xpath path, tokenization yeilds a concatenation of + parameterized xpath selectors. As with the DOM version, both + simple selector blocks and overall evaluators are cached to + prevent re-defintion + 4.) the resulting query dispatcher is called in the passed scope (by default the top-level document) + - for DOM queries, this results in a recursive, top-down + evaluation of nodes based on each simple query section + - xpath queries can, thankfully, be executed in one shot + 5.) matched nodes are pruned to ensure they are unique +*/ + +;(function(){ + // define everything in a closure for compressability reasons. "d" is an + // alias to "dojo" since it's so frequently used. This seems a + // transformation that the build system could perform on a per-file basis. + + //////////////////////////////////////////////////////////////////////// + // Utility code + //////////////////////////////////////////////////////////////////////// + + var d = dojo; + var childNodesName = dojo.isIE ? "children" : "childNodes"; + var caseSensitive = false; + + var getQueryParts = function(query){ + // summary: state machine for query tokenization + if(">~+".indexOf(query.charAt(query.length-1)) >= 0){ + query += " *" + } + query += " "; // ensure that we terminate the state machine + + var ts = function(s, e){ + return d.trim(query.slice(s, e)); + } + + // the overall data graph of the full query, as represented by queryPart objects + var qparts = []; + // state keeping vars + var inBrackets = -1; + var inParens = -1; + var inMatchFor = -1; + var inPseudo = -1; + var inClass = -1; + var inId = -1; + var inTag = -1; + var lc = ""; // the last character + var cc = ""; // the current character + var pStart; + // iteration vars + var x = 0; // index in the query + var ql = query.length; + var currentPart = null; // data structure representing the entire clause + var _cp = null; // the current pseudo or attr matcher + + var endTag = function(){ + if(inTag >= 0){ + var tv = (inTag == x) ? null : ts(inTag, x).toLowerCase(); + currentPart[ (">~+".indexOf(tv) < 0) ? "tag" : "oper" ] = tv; + inTag = -1; + } + } + + var endId = function(){ + if(inId >= 0){ + currentPart.id = ts(inId, x).replace(/\\/g, ""); + inId = -1; + } + } + + var endClass = function(){ + if(inClass >= 0){ + currentPart.classes.push(ts(inClass+1, x).replace(/\\/g, "")); + inClass = -1; + } + } + + var endAll = function(){ + endId(); endTag(); endClass(); + } + + for(; lc=cc, cc=query.charAt(x),x= 0){ + // look for a the close first + if(cc == "]"){ + if(!_cp.attr){ + _cp.attr = ts(inBrackets+1, x); + }else{ + _cp.matchFor = ts((inMatchFor||inBrackets+1), x); + } + var cmf = _cp.matchFor; + if(cmf){ + if( (cmf.charAt(0) == '"') || (cmf.charAt(0) == "'") ){ + _cp.matchFor = cmf.substring(1, cmf.length-1); + } + } + currentPart.attrs.push(_cp); + _cp = null; // necessaray? + inBrackets = inMatchFor = -1; + }else if(cc == "="){ + var addToCc = ("|~^$*".indexOf(lc) >=0 ) ? lc : ""; + _cp.type = addToCc+cc; + _cp.attr = ts(inBrackets+1, x-addToCc.length); + inMatchFor = x+1; + } + // now look for other clause parts + }else if(inParens >= 0){ + if(cc == ")"){ + if(inPseudo >= 0){ + _cp.value = ts(inParens+1, x); + } + inPseudo = inParens = -1; + } + }else if(cc == "#"){ + endAll(); + inId = x+1; + }else if(cc == "."){ + endAll(); + inClass = x; + }else if(cc == ":"){ + endAll(); + inPseudo = x; + }else if(cc == "["){ + endAll(); + inBrackets = x; + _cp = { + /*===== + attr: null, type: null, matchFor: null + =====*/ + }; + }else if(cc == "("){ + if(inPseudo >= 0){ + _cp = { + name: ts(inPseudo+1, x), + value: null + } + currentPart.pseudos.push(_cp); + } + inParens = x; + }else if(cc == " " && lc != cc){ + // note that we expect the string to be " " terminated + endAll(); + if(inPseudo >= 0){ + currentPart.pseudos.push({ name: ts(inPseudo+1, x) }); + } + currentPart.hasLoops = ( + currentPart.pseudos.length || + currentPart.attrs.length || + currentPart.classes.length ); + currentPart.query = ts(pStart, x); + currentPart.tag = (currentPart["oper"]) ? null : (currentPart.tag || "*"); + qparts.push(currentPart); + currentPart = null; + } + } + return qparts; + }; + + + //////////////////////////////////////////////////////////////////////// + // XPath query code + //////////////////////////////////////////////////////////////////////// + + // this array is a lookup used to generate an attribute matching function. + // There is a similar lookup/generator list for the DOM branch with similar + // calling semantics. + var xPathAttrs = { + "*=": function(attr, value){ + return "[contains(@"+attr+", '"+ value +"')]"; + }, + "^=": function(attr, value){ + return "[starts-with(@"+attr+", '"+ value +"')]"; + }, + "$=": function(attr, value){ + return "[substring(@"+attr+", string-length(@"+attr+")-"+(value.length-1)+")='"+value+"']"; + }, + "~=": function(attr, value){ + return "[contains(concat(' ',@"+attr+",' '), ' "+ value +" ')]"; + }, + "|=": function(attr, value){ + return "[contains(concat(' ',@"+attr+",' '), ' "+ value +"-')]"; + }, + "=": function(attr, value){ + return "[@"+attr+"='"+ value +"']"; + } + }; + + // takes a list of attribute searches, the overall query, a function to + // generate a default matcher, and a closure-bound method for providing a + // matching function that generates whatever type of yes/no distinguisher + // the query method needs. The method is a bit tortured and hard to read + // because it needs to be used in both the XPath and DOM branches. + var handleAttrs = function( attrList, + query, + getDefault, + handleMatch){ + d.forEach(query.attrs, function(attr){ + var matcher; + // type, attr, matchFor + if(attr.type && attrList[attr.type]){ + matcher = attrList[attr.type](attr.attr, attr.matchFor); + }else if(attr.attr.length){ + matcher = getDefault(attr.attr); + } + if(matcher){ handleMatch(matcher); } + }); + } + + var buildPath = function(query){ + var xpath = "."; + var qparts = getQueryParts(d.trim(query)); + while(qparts.length){ + var tqp = qparts.shift(); + var prefix; + var postfix = ""; + if(tqp.oper == ">"){ + prefix = "/"; + // prefix = "/child::*"; + tqp = qparts.shift(); + }else if(tqp.oper == "~"){ + prefix = "/following-sibling::"; // get element following siblings + tqp = qparts.shift(); + }else if(tqp.oper == "+"){ + // FIXME: + // fails when selecting subsequent siblings by node type + // because the position() checks the position in the list + // of matching elements and not the localized siblings + prefix = "/following-sibling::"; + postfix = "[position()=1]"; + tqp = qparts.shift(); + }else{ + prefix = "//"; + // prefix = "/descendant::*" + } + + // get the tag name (if any) + + xpath += prefix + tqp.tag + postfix; + + // check to see if it's got an id. Needs to come first in xpath. + if(tqp.id){ + xpath += "[@id='"+tqp.id+"'][1]"; + } + + d.forEach(tqp.classes, function(cn){ + var cnl = cn.length; + var padding = " "; + if(cn.charAt(cnl-1) == "*"){ + padding = ""; cn = cn.substr(0, cnl-1); + } + xpath += + "[contains(concat(' ',@class,' '), ' "+ + cn + padding + "')]"; + }); + + handleAttrs(xPathAttrs, tqp, + function(condition){ + return "[@"+condition+"]"; + }, + function(matcher){ + xpath += matcher; + } + ); + + // FIXME: need to implement pseudo-class checks!! + }; + return xpath; + }; + + var _xpathFuncCache = {}; + var getXPathFunc = function(path){ + if(_xpathFuncCache[path]){ + return _xpathFuncCache[path]; + } + + var doc = d.doc; + // don't need to memoize. The closure scope handles it for us. + var xpath = buildPath(path); + + var tf = function(parent){ + // XPath query strings are memoized. + var ret = []; + var xpathResult; + try{ + xpathResult = doc.evaluate(xpath, parent, null, + // XPathResult.UNORDERED_NODE_ITERATOR_TYPE, null); + XPathResult.ANY_TYPE, null); + }catch(e){ + console.debug("failure in exprssion:", xpath, "under:", parent); + console.debug(e); + } + var result = xpathResult.iterateNext(); + while(result){ + ret.push(result); + result = xpathResult.iterateNext(); + } + return ret; + } + return _xpathFuncCache[path] = tf; + }; + + /* + d.xPathMatch = function(query){ + // XPath based DOM query system. Handles a small subset of CSS + // selectors, subset is identical to the non-XPath version of this + // function. + + return getXPathFunc(query)(); + } + */ + + //////////////////////////////////////////////////////////////////////// + // DOM query code + //////////////////////////////////////////////////////////////////////// + + var _filtersCache = {}; + var _simpleFiltersCache = {}; + + // the basic building block of the yes/no chaining system. agree(f1, f2) + // generates a new function which returns the boolean results of both of + // the passed functions to a single logical-anded result. + var agree = function(first, second){ + if(!first){ return second; } + if(!second){ return first; } + + return function(){ + return first.apply(window, arguments) && second.apply(window, arguments); + } + } + + var _childElements = function(root){ + var ret = []; + var te, x=0, tret = root[childNodesName]; + while(te=tret[x++]){ + if(te.nodeType == 1){ ret.push(te); } + } + return ret; + } + + var _nextSiblings = function(root, single){ + var ret = []; + var te = root; + while(te = te.nextSibling){ + if(te.nodeType == 1){ + ret.push(te); + if(single){ break; } + } + } + return ret; + } + + var _filterDown = function(element, queryParts, matchArr, idx){ + // NOTE: + // in the fast path! this function is called recursively and for + // every run of a query. + var nidx = idx+1; + var isFinal = (queryParts.length == nidx); + var tqp = queryParts[idx]; + + // see if we can constrain our next level to direct children + if(tqp.oper){ + var ecn = (tqp.oper == ">") ? + _childElements(element) : + _nextSiblings(element, (tqp.oper == "+")); + + if(!ecn || !ecn.length){ + return; + } + nidx++; + isFinal = (queryParts.length == nidx); + // kinda janky, too much array alloc + var tf = getFilterFunc(queryParts[idx+1]); + // for(var x=ecn.length-1, te; x>=0, te=ecn[x]; x--){ + for(var x=0, ecnl=ecn.length, te; x=0, te=elements[x]; x--){ + var x = elements.length - 1, te; + while(te = elements[x--]){ + _filterDown(te, queryParts, ret, 0); + } + return ret; + } + + var getFilterFunc = function(q){ + // note: query can't have spaces! + if(_filtersCache[q.query]){ + return _filtersCache[q.query]; + } + var ff = null; + + // does it have a tagName component? + if(q.tag){ + if(q.tag == "*"){ + ff = agree(ff, + function(elem){ + return (elem.nodeType == 1); + } + ); + }else{ + // tag name match + ff = agree(ff, + function(elem){ + return ( + (elem.nodeType == 1) && + (q.tag == elem.tagName.toLowerCase()) + ); + // return isTn; + } + ); + } + } + + // does the node have an ID? + if(q.id){ + ff = agree(ff, + function(elem){ + return ( + (elem.nodeType == 1) && + (elem.id == q.id) + ); + } + ); + } + + if(q.hasLoops){ + // if we have other query param parts, make sure we add them to the + // filter chain + ff = agree(ff, getSimpleFilterFunc(q)); + } + + return _filtersCache[q.query] = ff; + } + + var getNodeIndex = function(node){ + // NOTE: + // we could have a more accurate caching mechanism by invalidating + // caches after the query has finished, but I think that'd lead to + // significantly more cache churn than the cache would provide + // value for in the common case. Generally, we're more + // conservative (and therefore, more accurate) than jQuery and + // DomQuery WRT node node indexes, but there may be corner cases + // in which we fall down. How much we care about them is TBD. + + var pn = node.parentNode; + var pnc = pn.childNodes; + + // check to see if we can trust the cache. If not, re-key the whole + // thing and return our node match from that. + + var nidx = -1; + var child = pn.firstChild; + if(!child){ + return nidx; + } + + var ci = node["__cachedIndex"]; + var cl = pn["__cachedLength"]; + + // only handle cache building if we've gone out of sync + if(((typeof cl == "number")&&(cl != pnc.length))||(typeof ci != "number")){ + // rip though the whole set, building cache indexes as we go + pn["__cachedLength"] = pnc.length; + var idx = 1; + do{ + // we only assign indexes for nodes with nodeType == 1, as per: + // http://www.w3.org/TR/css3-selectors/#nth-child-pseudo + // only elements are counted in the search order, and they + // begin at 1 for the first child's index + + if(child === node){ + nidx = idx; + } + if(child.nodeType == 1){ + child["__cachedIndex"] = idx; + idx++; + } + child = child.nextSibling; + }while(child); + }else{ + // NOTE: + // could be incorrect in some cases (node swaps involving the + // passed node, etc.), but we ignore those due to the relative + // unlikelihood of that occuring + nidx = ci; + } + return nidx; + } + + var firedCount = 0; + + var blank = ""; + var _getAttr = function(elem, attr){ + if(attr == "class"){ + return elem.className || blank; + } + if(attr == "for"){ + return elem.htmlFor || blank; + } + return elem.getAttribute(attr, 2) || blank; + } + + var attrs = { + "*=": function(attr, value){ + return function(elem){ + // E[foo*="bar"] + // an E element whose "foo" attribute value contains + // the substring "bar" + return (_getAttr(elem, attr).indexOf(value)>=0); + } + }, + "^=": function(attr, value){ + // E[foo^="bar"] + // an E element whose "foo" attribute value begins exactly + // with the string "bar" + return function(elem){ + return (_getAttr(elem, attr).indexOf(value)==0); + } + }, + "$=": function(attr, value){ + // E[foo$="bar"] + // an E element whose "foo" attribute value ends exactly + // with the string "bar" + var tval = " "+value; + return function(elem){ + var ea = " "+_getAttr(elem, attr); + return (ea.lastIndexOf(value)==(ea.length-value.length)); + } + }, + "~=": function(attr, value){ + // E[foo~="bar"] + // an E element whose "foo" attribute value is a list of + // space-separated values, one of which is exactly equal + // to "bar" + + // return "[contains(concat(' ',@"+attr+",' '), ' "+ value +" ')]"; + var tval = " "+value+" "; + return function(elem){ + var ea = " "+_getAttr(elem, attr)+" "; + return (ea.indexOf(tval)>=0); + } + }, + "|=": function(attr, value){ + // E[hreflang|="en"] + // an E element whose "hreflang" attribute has a + // hyphen-separated list of values beginning (from the + // left) with "en" + var valueDash = " "+value+"-"; + return function(elem){ + var ea = " "+(elem.getAttribute(attr, 2) || ""); + return ( + (ea == value) || + (ea.indexOf(valueDash)==0) + ); + } + }, + "=": function(attr, value){ + return function(elem){ + return (_getAttr(elem, attr) == value); + } + } + }; + + var pseudos = { + "first-child": function(name, condition){ + return function(elem){ + if(elem.nodeType != 1){ return false; } + // check to see if any of the previous siblings are elements + var fc = elem.previousSibling; + while(fc && (fc.nodeType != 1)){ + fc = fc.previousSibling; + } + return (!fc); + } + }, + "last-child": function(name, condition){ + return function(elem){ + if(elem.nodeType != 1){ return false; } + // check to see if any of the next siblings are elements + var nc = elem.nextSibling; + while(nc && (nc.nodeType != 1)){ + nc = nc.nextSibling; + } + return (!nc); + } + }, + "empty": function(name, condition){ + return function(elem){ + // DomQuery and jQuery get this wrong, oddly enough. + // The CSS 3 selectors spec is pretty explicit about + // it, too. + var cn = elem.childNodes; + var cnl = elem.childNodes.length; + // if(!cnl){ return true; } + for(var x=cnl-1; x >= 0; x--){ + var nt = cn[x].nodeType; + if((nt == 1)||(nt == 3)){ return false; } + } + return true; + } + }, + "contains": function(name, condition){ + return function(elem){ + // FIXME: I dislike this version of "contains", as + // whimsical attribute could set it off. An inner-text + // based version might be more accurate, but since + // jQuery and DomQuery also potentially get this wrong, + // I'm leaving it for now. + return (elem.innerHTML.indexOf(condition) >= 0); + } + }, + "not": function(name, condition){ + var ntf = getFilterFunc(getQueryParts(condition)[0]); + return function(elem){ + return (!ntf(elem)); + } + }, + "nth-child": function(name, condition){ + var pi = parseInt; + if(condition == "odd"){ + return function(elem){ + return ( + ((getNodeIndex(elem)) % 2) == 1 + ); + } + }else if((condition == "2n")|| + (condition == "even")){ + return function(elem){ + return ((getNodeIndex(elem) % 2) == 0); + } + }else if(condition.indexOf("0n+") == 0){ + var ncount = pi(condition.substr(3)); + return function(elem){ + return (elem.parentNode[childNodesName][ncount-1] === elem); + } + }else if( (condition.indexOf("n+") > 0) && + (condition.length > 3) ){ + var tparts = condition.split("n+", 2); + var pred = pi(tparts[0]); + var idx = pi(tparts[1]); + return function(elem){ + return ((getNodeIndex(elem) % pred) == idx); + } + }else if(condition.indexOf("n") == -1){ + var ncount = pi(condition); + return function(elem){ + return (getNodeIndex(elem) == ncount); + } + } + } + }; + + var defaultGetter = (d.isIE) ? function(cond){ + var clc = cond.toLowerCase(); + return function(elem){ + return elem[cond]||elem[clc]; + } + } : function(cond){ + return function(elem){ + return (elem && elem.getAttribute && elem.hasAttribute(cond)); + } + }; + + var getSimpleFilterFunc = function(query){ + + var fcHit = (_simpleFiltersCache[query.query]||_filtersCache[query.query]); + if(fcHit){ return fcHit; } + + var ff = null; + + // the only case where we'll need the tag name is if we came from an ID query + if(query.id){ // do we have an ID component? + if(query.tag != "*"){ + ff = agree(ff, function(elem){ + return (elem.tagName.toLowerCase() == query.tag); + }); + } + } + + // if there's a class in our query, generate a match function for it + d.forEach(query.classes, function(cname, idx, arr){ + // get the class name + var isWildcard = cname.charAt(cname.length-1) == "*"; + if(isWildcard){ + cname = cname.substr(0, cname.length-1); + } + // I dislike the regex thing, even if memozied in a cache, but it's VERY short + var re = new RegExp("(?:^|\\s)" + cname + (isWildcard ? ".*" : "") + "(?:\\s|$)"); + ff = agree(ff, function(elem){ + return re.test(elem.className); + }); + ff.count = idx; + }); + + d.forEach(query.pseudos, function(pseudo){ + if(pseudos[pseudo.name]){ + ff = agree(ff, pseudos[pseudo.name](pseudo.name, pseudo.value)); + } + }); + + handleAttrs(attrs, query, defaultGetter, + function(tmatcher){ ff = agree(ff, tmatcher); } + ); + if(!ff){ + ff = function(){ return true; }; + } + return _simpleFiltersCache[query.query] = ff; + } + + var _getElementsFuncCache = { }; + + var getElementsFunc = function(query, root){ + var fHit = _getElementsFuncCache[query.query]; + if(fHit){ return fHit; } + + // NOTE: this function is in the fast path! not memoized!!! + + // the query doesn't contain any spaces, so there's only so many + // things it could be + + if(query.id && !query.hasLoops && !query.tag){ + // ID-only query. Easy. + return _getElementsFuncCache[query.query] = function(root){ + // FIXME: if root != document, check for parenting! + return [ d.byId(query.id) ]; + } + } + + var filterFunc = getSimpleFilterFunc(query); + + var retFunc; + if(query.tag && query.id && !query.hasLoops){ + // we got a filtered ID search (e.g., "h4#thinger") + retFunc = function(root){ + var te = d.byId(query.id); + if(filterFunc(te)){ + return [ te ]; + } + } + }else{ + var tret; + + if(!query.hasLoops){ + // it's just a plain-ol elements-by-tag-name query from the root + retFunc = function(root){ + var ret = []; + var te, x=0, tret = root.getElementsByTagName(query.tag); + while(te=tret[x++]){ + ret.push(te); + } + return ret; + } + }else{ + retFunc = function(root){ + var ret = []; + var te, x=0, tret = root.getElementsByTagName(query.tag); + while(te=tret[x++]){ + if(filterFunc(te)){ + ret.push(te); + } + } + return ret; + } + } + } + return _getElementsFuncCache[query.query] = retFunc; + } + + var _partsCache = {}; + + //////////////////////////////////////////////////////////////////////// + // the query runner + //////////////////////////////////////////////////////////////////////// + + // this is the second level of spliting, from full-length queries (e.g., + // "div.foo .bar") into simple query expressions (e.g., ["div.foo", + // ".bar"]) + var _queryFuncCache = { + "*": d.isIE ? + function(root){ + return root.all; + } : + function(root){ + return root.getElementsByTagName("*"); + }, + "~": _nextSiblings, + "+": function(root){ return _nextSiblings(root, true); }, + ">": _childElements + }; + + var getStepQueryFunc = function(query){ + // if it's trivial, get a fast-path dispatcher + var qparts = getQueryParts(d.trim(query)); + // if(query[query.length-1] == ">"){ query += " *"; } + if(qparts.length == 1){ + var tt = getElementsFunc(qparts[0]); + tt.nozip = true; + return tt; + } + + // otherwise, break it up and return a runner that iterates over the parts recursively + var sqf = function(root){ + var localQueryParts = qparts.slice(0); // clone the src arr + var candidates; + if(localQueryParts[0].oper == ">"){ // FIXME: what if it's + or ~? + candidates = [ root ]; + // root = document; + }else{ + candidates = getElementsFunc(localQueryParts.shift())(root); + } + return filterDown(candidates, localQueryParts); + } + return sqf; + } + + // a specialized method that implements our primoridal "query optimizer". + // This allows us to dispatch queries to the fastest subsystem we can get. + var _getQueryFunc = ( + // NOTE: + // XPath on the Webkit nighlies is slower than it's DOM iteration + // for most test cases + // FIXME: + // we should try to capture some runtime speed data for each query + // function to determine on the fly if we should stick w/ the + // potentially optimized variant or if we should try something + // new. + (document["evaluate"] && !d.isSafari) ? + function(query){ + // has xpath support that's faster than DOM + var qparts = query.split(" "); + // can we handle it? + if( (document["evaluate"])&& + (query.indexOf(":") == -1)&& + (query.indexOf("+") == -1) // skip direct sibling matches. See line ~344 + ){ + // dojo.debug(query); + // should we handle it? + + // kind of a lame heuristic, but it works + if( + // a "div div div" style query + ((qparts.length > 2)&&(query.indexOf(">") == -1))|| + // or something else with moderate complexity. kinda janky + (qparts.length > 3)|| + (query.indexOf("[")>=0)|| + // or if it's a ".thinger" query + ((1 == qparts.length)&&(0 <= query.indexOf("."))) + + ){ + // use get and cache a xpath runner for this selector + return getXPathFunc(query); + } + } + + // fallthrough + return getStepQueryFunc(query); + } : getStepQueryFunc + ); + // uncomment to disable XPath for testing and tuning the DOM path + // _getQueryFunc = getStepQueryFunc; + + // FIXME: we've got problems w/ the NodeList query()/filter() functions if we go XPath for everything + + // uncomment to disable DOM queries for testing and tuning XPath + // _getQueryFunc = getXPathFunc; + + // this is the primary caching for full-query results. The query dispatcher + // functions are generated here and then pickled for hash lookup in the + // future + var getQueryFunc = function(query){ + // return a cached version if one is available + var qcz = query.charAt(0); + if(d.doc["querySelectorAll"] && + ( (!d.isSafari) || (d.isSafari > 3.1) ) && // see #5832 + // as per CSS 3, we can't currently start w/ combinator: + // http://www.w3.org/TR/css3-selectors/#w3cselgrammar + (">+~".indexOf(qcz) == -1) + ){ + return function(root){ + var r = root.querySelectorAll(query); + r.nozip = true; // skip expensive duplication checks and just wrap in a NodeList + return r; + }; + } + if(_queryFuncCache[query]){ return _queryFuncCache[query]; } + if(0 > query.indexOf(",")){ + // if it's not a compound query (e.g., ".foo, .bar"), cache and return a dispatcher + return _queryFuncCache[query] = _getQueryFunc(query); + }else{ + // if it's a complex query, break it up into it's constituent parts + // and return a dispatcher that will merge the parts when run + + // var parts = query.split(", "); + var parts = query.split(/\s*,\s*/); + var tf = function(root){ + var pindex = 0; // avoid array alloc for every invocation + var ret = []; + var tp; + while(tp = parts[pindex++]){ + ret = ret.concat(_getQueryFunc(tp, tp.indexOf(" "))(root)); + } + return ret; + } + // ...cache and return + return _queryFuncCache[query] = tf; + } + } + + // FIXME: + // Dean's Base2 uses a system whereby queries themselves note if + // they'll need duplicate filtering. We need to get on that plan!! + + // attempt to efficiently determine if an item in a list is a dupe, + // returning a list of "uniques", hopefully in doucment order + var _zipIdx = 0; + var _zip = function(arr){ + if(arr && arr.nozip){ return d.NodeList._wrap(arr); } + var ret = new d.NodeList(); + if(!arr){ return ret; } + if(arr[0]){ + ret.push(arr[0]); + } + if(arr.length < 2){ return ret; } + _zipIdx++; + arr[0]["_zipIdx"] = _zipIdx; + for(var x=1, te; te = arr[x]; x++){ + if(arr[x]["_zipIdx"] != _zipIdx){ + ret.push(te); + } + te["_zipIdx"] = _zipIdx; + } + // FIXME: should we consider stripping these properties? + return ret; + } + + // the main executor + d.query = function(/*String*/ query, /*String|DOMNode?*/ root){ + // summary: + // Returns nodes which match the given CSS3 selector, searching the + // entire document by default but optionally taking a node to scope + // the search by. Returns an instance of dojo.NodeList. + // description: + // dojo.query() is the swiss army knife of DOM node manipulation in + // Dojo. Much like Prototype's "$$" (bling-bling) function or JQuery's + // "$" function, dojo.query provides robust, high-performance + // CSS-based node selector support with the option of scoping searches + // to a particular sub-tree of a document. + // + // Supported Selectors: + // -------------------- + // + // dojo.query() supports a rich set of CSS3 selectors, including: + // + // * class selectors (e.g., `.foo`) + // * node type selectors like `span` + // * ` ` descendant selectors + // * `>` child element selectors + // * `#foo` style ID selectors + // * `*` universal selector + // * `~`, the immediately preceeded-by sibling selector + // * `+`, the preceeded-by sibling selector + // * attribute queries: + // | * `[foo]` attribute presence selector + // | * `[foo='bar']` attribute value exact match + // | * `[foo~='bar']` attribute value list item match + // | * `[foo^='bar']` attribute start match + // | * `[foo$='bar']` attribute end match + // | * `[foo*='bar']` attribute substring match + // * `:first-child`, `:last-child` positional selectors + // * `:empty` content emtpy selector + // * `:empty` content emtpy selector + // * `:nth-child(n)`, `:nth-child(2n+1)` style positional calculations + // * `:nth-child(even)`, `:nth-child(odd)` positional selectors + // * `:not(...)` negation pseudo selectors + // + // Any legal combination of these selectors will work with + // `dojo.query()`, including compound selectors ("," delimited). + // Very complex and useful searches can be constructed with this + // palette of selectors and when combined with functions for + // maniplation presented by dojo.NodeList, many types of DOM + // manipulation operations become very straightforward. + // + // Unsupported Selectors: + // ---------------------- + // + // While dojo.query handles many CSS3 selectors, some fall outside of + // what's resaonable for a programmatic node querying engine to + // handle. Currently unsupported selectors include: + // + // * namespace-differentiated selectors of any form + // * all `::` pseduo-element selectors + // * certain pseduo-selectors which don't get a lot of day-to-day use: + // | * `:root`, `:lang()`, `:target`, `:focus` + // * all visual and state selectors: + // | * `:root`, `:active`, `:hover`, `:visisted`, `:link`, + // `:enabled`, `:disabled`, `:checked` + // * `:*-of-type` pseudo selectors + // + // dojo.query and XML Documents: + // ----------------------------- + // + // `dojo.query` currently only supports searching XML documents + // whose tags and attributes are 100% lower-case. This is a known + // limitation and will [be addressed soon](http://trac.dojotoolkit.org/ticket/3866) + // Non-selector Queries: + // --------------------- + // + // If something other than a String is passed for the query, + // `dojo.query` will return a new `dojo.NodeList` constructed from + // that parameter alone and all further processing will stop. This + // means that if you have a reference to a node or NodeList, you + // can quickly construct a new NodeList from the original by + // calling `dojo.query(node)` or `dojo.query(list)`. + // + // query: + // The CSS3 expression to match against. For details on the syntax of + // CSS3 selectors, see + // root: + // A DOMNode (or node id) to scope the search from. Optional. + // returns: dojo.NodeList + // An instance of `dojo.NodeList`. Many methods are available on + // NodeLists for searching, iterating, manipulating, and handling + // events on the matched nodes in the returned list. + // example: + // search the entire document for elements with the class "foo": + // | dojo.query(".foo"); + // these elements will match: + // | + // | + // |

+ // example: + // search the entire document for elements with the classes "foo" *and* "bar": + // | dojo.query(".foo.bar"); + // these elements will match: + // | + // while these will not: + // | + // |

+ // example: + // find `` elements which are descendants of paragraphs and + // which have a "highlighted" class: + // | dojo.query("p span.highlighted"); + // the innermost span in this fragment matches: + // |

+ // | ... + // | ... + // | + // |

+ // example: + // set an "odd" class on all odd table rows inside of the table + // `#tabular_data`, using the `>` (direct child) selector to avoid + // affecting any nested tables: + // | dojo.query("#tabular_data > tbody > tr:nth-child(odd)").addClass("odd"); + // example: + // remove all elements with the class "error" from the document + // and store them in a list: + // | var errors = dojo.query(".error").orphan(); + // example: + // add an onclick handler to every submit button in the document + // which causes the form to be sent via Ajax instead: + // | dojo.query("input[type='submit']").onclick(function(e){ + // | dojo.stopEvent(e); // prevent sending the form + // | var btn = e.target; + // | dojo.xhrPost({ + // | form: btn.form, + // | load: function(data){ + // | // replace the form with the response + // | var div = dojo.doc.createElement("div"); + // | dojo.place(div, btn.form, "after"); + // | div.innerHTML = data; + // | dojo.style(btn.form, "display", "none"); + // | } + // | }); + // | }); + + + // NOTE: elementsById is not currently supported + // NOTE: ignores xpath-ish queries for now + + if(query.constructor == d.NodeList){ + return query; + } + if(!d.isString(query)){ + return new d.NodeList(query); // dojo.NodeList + } + if(d.isString(root)){ + root = d.byId(root); + } + + return _zip(getQueryFunc(query)(root||d.doc)); // dojo.NodeList + } + + /* + // exposing this was a mistake + d.query.attrs = attrs; + */ + // exposing this because new pseudo matches are only executed through the + // DOM query path (never through the xpath optimizing branch) + d.query.pseudos = pseudos; + + // one-off function for filtering a NodeList based on a simple selector + d._filterQueryResult = function(nodeList, simpleFilter){ + var tnl = new d.NodeList(); + var ff = (simpleFilter) ? getFilterFunc(getQueryParts(simpleFilter)[0]) : function(){ return true; }; + for(var x=0, te; te = nodeList[x]; x++){ + if(ff(te)){ tnl.push(te); } + } + return tnl; + } +})(); + +} diff --git a/includes/js/dojo/_base/window.js b/includes/js/dojo/_base/window.js new file mode 100644 index 0000000..892768d --- /dev/null +++ b/includes/js/dojo/_base/window.js @@ -0,0 +1,145 @@ +if(!dojo._hasResource["dojo._base.window"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.window"] = true; +dojo.provide("dojo._base.window"); + +dojo._gearsObject = function(){ + // summary: + // factory method to get a Google Gears plugin instance to + // expose in the browser runtime environment, if present + var factory; + var results; + + var gearsObj = dojo.getObject("google.gears"); + if(gearsObj){ return gearsObj; } // already defined elsewhere + + if(typeof GearsFactory != "undefined"){ // Firefox + factory = new GearsFactory(); + }else{ + if(dojo.isIE){ + // IE + try{ + factory = new ActiveXObject("Gears.Factory"); + }catch(e){ + // ok to squelch; there's no gears factory. move on. + } + }else if(navigator.mimeTypes["application/x-googlegears"]){ + // Safari? + factory = document.createElement("object"); + factory.setAttribute("type", "application/x-googlegears"); + factory.setAttribute("width", 0); + factory.setAttribute("height", 0); + factory.style.display = "none"; + document.documentElement.appendChild(factory); + } + } + + // still nothing? + if(!factory){ return null; } + + // define the global objects now; don't overwrite them though if they + // were somehow set internally by the Gears plugin, which is on their + // dev roadmap for the future + dojo.setObject("google.gears.factory", factory); + return dojo.getObject("google.gears"); +}; + +/*===== +dojo.isGears = { + // summary: True if client is using Google Gears +}; +=====*/ +// see if we have Google Gears installed, and if +// so, make it available in the runtime environment +// and in the Google standard 'google.gears' global object +dojo.isGears = (!!dojo._gearsObject())||0; + +/*===== +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 = window["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 = globalObject; + dojo.doc = globalDocument; +}; + +dojo._fireCallback = function(callback, context, cbArguments){ + if(context && dojo.isString(callback)){ + callback = context[callback]; + } + return callback.apply(context, cbArguments || [ ]); +} + +dojo.withGlobal = function( /*Object*/globalObject, + /*Function*/callback, + /*Object?*/thisObject, + /*Array?*/cbArguments){ + // summary: + // Call callback with globalObject as dojo.global and + // globalObject.document as dojo.doc. If provided, globalObject + // will be executed in the context of object thisObject + // description: + // When callback() returns or throws an error, the dojo.global + // and dojo.doc will be restored to its previous state. + var rval; + var oldGlob = dojo.global; + var oldDoc = dojo.doc; + try{ + dojo.setContext(globalObject, globalObject.document); + rval = dojo._fireCallback(callback, thisObject, cbArguments); + }finally{ + dojo.setContext(oldGlob, oldDoc); + } + return rval; +} + +dojo.withDoc = function( /*Object*/documentObject, + /*Function*/callback, + /*Object?*/thisObject, + /*Array?*/cbArguments){ + // summary: + // Call callback with documentObject as dojo.doc. If provided, + // callback will be executed in the context of object thisObject + // description: + // When callback() returns or throws an error, the dojo.doc will + // be restored to its previous state. + var rval; + var oldDoc = dojo.doc; + try{ + dojo.doc = documentObject; + rval = dojo._fireCallback(callback, thisObject, cbArguments); + }finally{ + dojo.doc = oldDoc; + } + return rval; +}; + +} diff --git a/includes/js/dojo/_base/xhr.js b/includes/js/dojo/_base/xhr.js new file mode 100644 index 0000000..f6e7f1a --- /dev/null +++ b/includes/js/dojo/_base/xhr.js @@ -0,0 +1,730 @@ +if(!dojo._hasResource["dojo._base.xhr"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dojo._base.xhr"] = true; +dojo.provide("dojo._base.xhr"); +dojo.require("dojo._base.Deferred"); +dojo.require("dojo._base.json"); +dojo.require("dojo._base.lang"); +dojo.require("dojo._base.query"); + +(function(){ + var _d = dojo; + function setValue(/*Object*/obj, /*String*/name, /*String*/value){ + //summary: + // For the nameed property in object, set the value. If a value + // already exists and it is a string, convert the value to be an + // array of values. + var val = obj[name]; + if(_d.isString(val)){ + obj[name] = [val, value]; + }else if(_d.isArray(val)){ + val.push(value); + }else{ + obj[name] = value; + } + } + + dojo.formToObject = function(/*DOMNode||String*/ formNode){ + // summary: + // dojo.formToObject returns the values encoded in an HTML form as + // string properties in an object which it then returns. Disabled form + // elements, buttons, and other non-value form elements are skipped. + // Multi-select elements are returned as an array of string values. + // description: + // This form: + // + // |
+ // | + // | + // | + // | + // |
+ // + // yields this object structure as the result of a call to + // formToObject(): + // + // | { + // | blah: "blah", + // | multi: [ + // | "thud", + // | "thonk" + // | ] + // | }; + + var ret = {}; + var iq = "input:not([type=file]):not([type=submit]):not([type=image]):not([type=reset]):not([type=button]), select, textarea"; + _d.query(iq, formNode).filter(function(node){ + return !node.disabled && node.name; + }).forEach(function(item){ + var _in = item.name; + var type = (item.type||"").toLowerCase(); + if(type == "radio" || type == "checkbox"){ + if(item.checked){ setValue(ret, _in, item.value); } + }else if(item.multiple){ + ret[_in] = []; + _d.query("option", item).forEach(function(opt){ + if(opt.selected){ + setValue(ret, _in, opt.value); + } + }); + }else{ + setValue(ret, _in, item.value); + if(type == "image"){ + ret[_in+".x"] = ret[_in+".y"] = ret[_in].x = ret[_in].y = 0; + } + } + }); + return ret; // Object + } + + dojo.objectToQuery = function(/*Object*/ map){ + // summary: + // takes a name/value mapping object and returns a string representing + // a URL-encoded version of that object. + // example: + // this object: + // + // | { + // | blah: "blah", + // | multi: [ + // | "thud", + // | "thonk" + // | ] + // | }; + // + // yields the following query string: + // + // | "blah=blah&multi=thud&multi=thonk" + + // FIXME: need to implement encodeAscii!! + var enc = encodeURIComponent; + var pairs = []; + var backstop = {}; + for(var name in map){ + var value = map[name]; + if(value != backstop[name]){ + var assign = enc(name) + "="; + if(_d.isArray(value)){ + for(var i=0; i < value.length; i++){ + pairs.push(assign + enc(value[i])); + } + }else{ + pairs.push(assign + enc(value)); + } + } + } + return pairs.join("&"); // String + } + + dojo.formToQuery = function(/*DOMNode||String*/ formNode){ + // summary: + // Returns a URL-encoded string representing the form passed as either a + // node or string ID identifying the form to serialize + return _d.objectToQuery(_d.formToObject(formNode)); // String + } + + dojo.formToJson = function(/*DOMNode||String*/ formNode, /*Boolean?*/prettyPrint){ + // summary: + // return a serialized JSON string from a form node or string + // ID identifying the form to serialize + return _d.toJson(_d.formToObject(formNode), prettyPrint); // String + } + + dojo.queryToObject = function(/*String*/ str){ + // summary: + // returns an object representing a de-serialized query section of a + // URL. Query keys with multiple values are returned in an array. + // description: + // This string: + // + // | "foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&" + // + // results in this object structure: + // + // | { + // | foo: [ "bar", "baz" ], + // | thinger: " spaces =blah", + // | zonk: "blarg" + // | } + // + // Note that spaces and other urlencoded entities are correctly + // handled. + + // FIXME: should we grab the URL string if we're not passed one? + var ret = {}; + var qp = str.split("&"); + var dec = decodeURIComponent; + _d.forEach(qp, function(item){ + if(item.length){ + var parts = item.split("="); + var name = dec(parts.shift()); + var val = dec(parts.join("=")); + if(_d.isString(ret[name])){ + ret[name] = [ret[name]]; + } + if(_d.isArray(ret[name])){ + ret[name].push(val); + }else{ + ret[name] = val; + } + } + }); + return ret; // Object + } + + /* + from refactor.txt: + + all bind() replacement APIs take the following argument structure: + + { + url: "blah.html", + + // all below are optional, but must be supported in some form by + // every IO API + timeout: 1000, // milliseconds + handleAs: "text", // replaces the always-wrong "mimetype" + content: { + key: "value" + }, + + // browser-specific, MAY be unsupported + sync: true, // defaults to false + form: dojo.byId("someForm") + } + */ + + // 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; + + dojo._contentHandlers = { + "text": function(xhr){ return xhr.responseText; }, + "json": function(xhr){ + if(!dojo.config.usePlainJson){ + console.warn("Consider using mimetype:text/json-comment-filtered" + + " to avoid potential security issues with JSON endpoints" + + " (use djConfig.usePlainJson=true to turn off this message)"); + } + return (xhr.status == 204) ? undefined : _d.fromJson(xhr.responseText); + }, + "json-comment-filtered": function(xhr){ + // NOTE: we provide the json-comment-filtered option as one solution to + // the "JavaScript Hijacking" issue noted by Fortify and others. It is + // not appropriate for all circumstances. + + 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 (xhr.status == 204) ? undefined : + _d.fromJson(value.substring(cStartIdx+2, cEndIdx)); + }, + "javascript": function(xhr){ + // FIXME: try Moz and IE specific eval variants? + return _d.eval(xhr.responseText); + }, + "xml": function(xhr){ + var result = xhr.responseXML; + if(_d.isIE && (!result || window.location.protocol == "file:")){ + _d.forEach(["MSXML2", "Microsoft", "MSXML", "MSXML3"], function(prefix){ + try{ + var dom = new ActiveXObject(prefix + ".XMLDOM"); + dom.async = false; + dom.loadXML(xhr.responseText); + result = dom; + }catch(e){ /* Not available. Squelch and try next one. */ } + }); + } + return result; // DOMDocument + } + }; + + dojo._contentHandlers["json-comment-optional"] = function(xhr){ + var handlers = _d._contentHandlers; + try{ + return handlers["json-comment-filtered"](xhr); + }catch(e){ + 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). + // load: Function? + // function(response, ioArgs){}. response is an Object, ioArgs + // is of type dojo.__IoCallbackArgs. The load function will be + // called on a successful response. + // error: Function? + // function(response, ioArgs){}. response is an Object, ioArgs + // is of type dojo.__IoCallbackArgs. The error function will + // be called in an error case. + // handle: Function? + // function(response, ioArgs){}. response is an Object, ioArgs + // is of type dojo.__IoCallbackArgs. The handle function will + // be called in either the successful or error case. For + // the load, error and handle functions, the ioArgs object + // will contain the following properties: + this.url = url; + this.content = content; + this.timeout = timeout; + this.form = form; + this.preventCache = preventCache; + this.handleAs = handleAs; + this.load = load; + this.error = error; + this.handle = handle; + } + =====*/ + + /*===== + 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._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 = _d.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 = _d.formToObject(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 = _d.objectToQuery(_d.mixin.apply(null, miArgs)); + + // .. and the real work of getting the deferred in order, etc. + ioArgs.handleAs = args.handleAs || "text"; + var d = new _d.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 && _d.isFunction(ld)){ + d.addCallback(function(value){ + return ld.call(args, value, ioArgs); + }); + } + var err = args.error; + if(err && _d.isFunction(err)){ + d.addErrback(function(value){ + return err.call(args, value, ioArgs); + }); + } + var handle = args.handle; + if(handle && _d.isFunction(handle)){ + d.addBoth(function(value){ + return handle.call(args, value, ioArgs); + }); + } + + 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 == "unknown"){ + xhr.abort(); + } + var err = new Error("xhr cancelled"); + err.dojoType = "cancel"; + return err; + } + var _deferredOk = function(/*Deferred*/dfd){ + //summary: okHandler function for dojo._ioSetArgs call. + + return _d._contentHandlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr); + } + var _deferError = function(/*Error*/error, /*Deferred*/dfd){ + //summary: errHandler function for dojo._ioSetArgs call. + + // console.debug("xhr error in:", dfd.ioArgs.xhr); + console.debug(error); + return error; + } + + var _makeXhrDeferred = function(/*dojo.__XhrArgs*/args){ + //summary: makes the Deferred object for this xhr request. + var dfd = _d._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError); + //Pass the args to _xhrObj, to allow xhr iframe proxy interceptions. + dfd.ioArgs.xhr = _d._xhrObj(dfd.ioArgs.args); + return dfd; + } + + // 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 = []; + 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(!_d._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; + try{ + if(!dfd || dfd.canceled || !tif.validCheck(dfd)){ + _inFlight.splice(i--, 1); + }else if(tif.ioCheck(dfd)){ + _inFlight.splice(i--, 1); + tif.resHandle(dfd); + }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(); + } + } + }catch(e){ + // FIXME: make sure we errback! (fixed? remove console.debug?) + console.debug(e); + dfd.errback(new Error("_watchInFlightError!")); + } + } + } + + if(!_inFlight.length){ + clearInterval(_inFlightIntvl); + _inFlightIntvl = null; + return; + } + + } + + dojo._ioCancelAll = function(){ + //summary: Cancels all pending IO requests, regardless of IO type + //(xhr, script, iframe). + try{ + _d.forEach(_inFlight, function(i){ + i.dfd.cancel(); + }); + }catch(e){/*squelch*/} + } + + //Automatically call cancel all io calls on unload + //in IE for trac issue #2357. + if(_d.isIE){ + _d.addOnUnload(_d._ioCancelAll); + } + + _d._ioWatch = function(/*Deferred*/dfd, + /*Function*/validCheck, + /*Function*/ioCheck, + /*Function*/resHandle){ + //summary: watches the io request represented by dfd to see if it completes. + //dfd: + // The Deferred object to watch. + //validCheck: + // Function used to check if the IO request is still valid. Gets the dfd + // object as its only argument. + //ioCheck: + // Function used to check if basic IO call worked. Gets the dfd + // object as its only argument. + //resHandle: + // Function used to process response. Gets the dfd + // object as its only argument. + if(dfd.ioArgs.args.timeout){ + dfd.startTime = (new Date()).getTime(); + } + _inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle}); + if(!_inFlightIntvl){ + _inFlightIntvl = setInterval(_watchInFlight, 50); + } + _watchInFlight(); // handle sync requests + } + + 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(_d._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; + dfd.errback(err); + } + } + + var _doIt = function(/*String*/type, /*Deferred*/dfd){ + // 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" + var ioArgs = dfd.ioArgs; + var args = ioArgs.args; + var xhr = ioArgs.xhr; + xhr.open(type, 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{ + xhr.setRequestHeader(hdr, args.headers[hdr]); + } + } + } + // FIXME: is this appropriate for all content types? + xhr.setRequestHeader("Content-Type", args.contentType || _defaultContentType); + if(!args.headers || !args.headers["X-Requested-With"]){ + xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest"); + } + // FIXME: set other headers here! + try{ + xhr.send(ioArgs.query); + }catch(e){ + dfd.cancel(); + } + _d._ioWatch(dfd, _validCheck, _ioCheck, _resHandle); + xhr = null; + return dfd; //Deferred + } + + 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 + // 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. + this.handleAs = handleAs; + this.sync = sync; + this.headers = headers; + } + }); + =====*/ + + dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){ + // summary: + // Sends an HTTP request with the given method. If the request has an + // HTTP body, then pass true for hasBody. The method argument should be uppercase. + // Also look at 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. + var dfd = _makeXhrDeferred(args); + if(!hasBody){ + _d._ioAddQueryToUrl(dfd.ioArgs); + } + return _doIt(method, dfd); // dojo.Deferred + } + + dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){ + // summary: + // Sends an HTTP GET request to the server. + return _d.xhr("GET", args); //dojo.Deferred + } + + dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){ + //summary: + // Sends an HTTP POST request to the server. + return _d.xhr("POST", args, true); // dojo.Deferred + } + + dojo.rawXhrPost = 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. The raw data to send in the body of the POST request. + var dfd = _makeXhrDeferred(args); + dfd.ioArgs.query = args.postData; + return _doIt("POST", dfd); // dojo.Deferred + } + + dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){ + // summary: + // Sends an HTTP PUT request to the server. + return _d.xhr("PUT", args, true); // dojo.Deferred + } + + dojo.rawXhrPut = 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. The raw data to send in the body of the PUT request. + var dfd = _makeXhrDeferred(args); + var ioArgs = dfd.ioArgs; + if(args.putData){ + ioArgs.query = args.putData; + args.putData = null; + } + return _doIt("PUT", dfd); // dojo.Deferred + } + + dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){ + // summary: + // Sends an HTTP DELETE request to the server. + return _d.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"); + } + */ +})(); + +} -- cgit v1.2.3-54-g00ecf