16) wa=core(wa,key.length*chrsz);
+ var l=[], r=[];
+ for(var i=0; i<16; i++){
+ l[i]=wa[i]^0x36363636;
+ r[i]=wa[i]^0x5c5c5c5c;
+ }
+ var h=core(l.concat(toWord(data)),512+data.length*chrsz);
+ return core(r.concat(h),640);
+ }
+
+ this.compute=function(data,outputType){
+ var out=outputType||dojo.crypto.outputTypes.Base64;
+ switch(out){
+ case dojo.crypto.outputTypes.Hex:{
+ return toHex(core(toWord(data),data.length*chrsz));
+ }
+ case dojo.crypto.outputTypes.String:{
+ return toString(core(toWord(data),data.length*chrsz));
+ }
+ default:{
+ return toBase64(core(toWord(data),data.length*chrsz));
+ }
+ }
+ };
+ this.getHMAC=function(data,key,outputType){
+ var out=outputType||dojo.crypto.outputTypes.Base64;
+ switch(out){
+ case dojo.crypto.outputTypes.Hex:{
+ return toHex(hmac(data,key));
+ }
+ case dojo.crypto.outputTypes.String:{
+ return toString(hmac(data,key));
+ }
+ default:{
+ return toBase64(hmac(data,key));
+ }
+ }
+ };
+}();
diff --git a/source/web/scripts/ajax/dojo/src/crypto/SHA256.js b/source/web/scripts/ajax/dojo/src/crypto/SHA256.js
new file mode 100644
index 0000000000..00a97c6b83
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/crypto/SHA256.js
@@ -0,0 +1,20 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.crypto.SHA256");
+dojo.require("dojo.crypto");
+dojo.require("dojo.experimental");
+
+dojo.experimental("dojo.crypto.SHA256");
+
+dojo.crypto.SHA256 = new function(){
+ this.compute=function(s){
+ };
+}();
diff --git a/source/web/scripts/ajax/dojo/src/crypto/__package__.js b/source/web/scripts/ajax/dojo/src/crypto/__package__.js
new file mode 100644
index 0000000000..652b66d795
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/crypto/__package__.js
@@ -0,0 +1,17 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.kwCompoundRequire({
+ common: [
+ "dojo.crypto",
+ "dojo.crypto.MD5"
+ ]
+});
+dojo.provide("dojo.crypto.*");
diff --git a/source/web/scripts/ajax/dojo/src/data.js b/source/web/scripts/ajax/dojo/src/data.js
new file mode 100644
index 0000000000..36532e9f77
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data.js
@@ -0,0 +1,15 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data");
+
+// currently a stub for dojo.data
+
+dojo.data = {};
diff --git a/source/web/scripts/ajax/dojo/src/data/CsvStore.js b/source/web/scripts/ajax/dojo/src/data/CsvStore.js
new file mode 100644
index 0000000000..b9da442671
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/CsvStore.js
@@ -0,0 +1,207 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.CsvStore");
+dojo.require("dojo.data.core.RemoteStore");
+dojo.require("dojo.lang.assert");
+
+dojo.declare("dojo.data.CsvStore", dojo.data.core.RemoteStore, {
+ /* summary:
+ * The CsvStore subclasses dojo.data.core.RemoteStore to implement
+ * the dojo.data.core.Read API.
+ */
+
+ /* examples:
+ * var csvStore = new dojo.data.CsvStore({queryUrl:"movies.csv");
+ * var csvStore = new dojo.data.CsvStore({url:"http://example.com/movies.csv");
+ */
+ _setupQueryRequest: function(/* dojo.data.core.Result */ result, /* object */ requestKw) {
+ // summary: See dojo.data.core.RemoteStore._setupQueryRequest()
+ var serverQueryUrl = this._serverQueryUrl ? this._serverQueryUrl : "";
+ var queryUrl = result.query ? result.query : "";
+ requestKw.url = serverQueryUrl + queryUrl;
+ requestKw.method = 'get';
+ },
+
+ _resultToQueryData: function(/* varies */ serverResponseData) {
+ // summary: See dojo.data.core.RemoteStore._resultToQueryData()
+ var csvFileContentString = serverResponseData;
+ var arrayOfArrays = this._getArrayOfArraysFromCsvFileContents(csvFileContentString);
+ var arrayOfObjects = this._getArrayOfObjectsFromArrayOfArrays(arrayOfArrays);
+ var remoteStoreData = this._getRemoteStoreDataFromArrayOfObjects(arrayOfObjects);
+ return remoteStoreData;
+ },
+
+ _setupSaveRequest: function(/* object */ saveKeywordArgs, /* object */ requestKw) {
+ // summary: See dojo.data.core.RemoteStore._setupSaveRequest()
+ // description: NOT IMPLEMENTED -- CsvStore is a read-only store
+ },
+
+ // -------------------------------------------------------------------
+ // Private methods
+ _getArrayOfArraysFromCsvFileContents: function(/* string */ csvFileContents) {
+ /* summary:
+ * Parses a string of CSV records into a nested array structure.
+ * description:
+ * Given a string containing CSV records, this method parses
+ * the string and returns a data structure containing the parsed
+ * content. The data structure we return is an array of length
+ * R, where R is the number of rows (lines) in the CSV data. The
+ * return array contains one sub-array for each CSV line, and each
+ * sub-array contains C string values, where C is the number of
+ * columns in the CSV data.
+ */
+
+ /* example:
+ * For example, given this CSV string as input:
+ * "Title, Year, Producer \n Alien, 1979, Ridley Scott \n Blade Runner, 1982, Ridley Scott"
+ * We will return this data structure:
+ * [["Title", "Year", "Producer"]
+ * ["Alien", "1979", "Ridley Scott"],
+ * ["Blade Runner", "1982", "Ridley Scott"]]
+ */
+ dojo.lang.assertType(csvFileContents, String);
+
+ var lineEndingCharacters = new RegExp("\r\n|\n|\r");
+ var leadingWhiteSpaceCharacters = new RegExp("^\\s+",'g');
+ var trailingWhiteSpaceCharacters = new RegExp("\\s+$",'g');
+ var doubleQuotes = new RegExp('""','g');
+ var arrayOfOutputRecords = [];
+
+ var arrayOfInputLines = csvFileContents.split(lineEndingCharacters);
+ for (var i in arrayOfInputLines) {
+ var singleLine = arrayOfInputLines[i];
+ if (singleLine.length > 0) {
+ var listOfFields = singleLine.split(',');
+ var j = 0;
+ while (j < listOfFields.length) {
+ var space_field_space = listOfFields[j];
+ var field_space = space_field_space.replace(leadingWhiteSpaceCharacters, ''); // trim leading whitespace
+ var field = field_space.replace(trailingWhiteSpaceCharacters, ''); // trim trailing whitespace
+ var firstChar = field.charAt(0);
+ var lastChar = field.charAt(field.length - 1);
+ var secondToLastChar = field.charAt(field.length - 2);
+ var thirdToLastChar = field.charAt(field.length - 3);
+ if ((firstChar == '"') &&
+ ((lastChar != '"') ||
+ ((lastChar == '"') && (secondToLastChar == '"') && (thirdToLastChar != '"')) )) {
+ if (j+1 === listOfFields.length) {
+ // alert("The last field in record " + i + " is corrupted:\n" + field);
+ return null;
+ }
+ var nextField = listOfFields[j+1];
+ listOfFields[j] = field_space + ',' + nextField;
+ listOfFields.splice(j+1, 1); // delete element [j+1] from the list
+ } else {
+ if ((firstChar == '"') && (lastChar == '"')) {
+ field = field.slice(1, (field.length - 1)); // trim the " characters off the ends
+ field = field.replace(doubleQuotes, '"'); // replace "" with "
+ }
+ listOfFields[j] = field;
+ j += 1;
+ }
+ }
+ arrayOfOutputRecords.push(listOfFields);
+ }
+ }
+ return arrayOfOutputRecords; // Array
+ },
+
+ _getArrayOfObjectsFromArrayOfArrays: function(/* array[] */ arrayOfArrays) {
+ /* summary:
+ * Converts a nested array structure into an array of keyword objects.
+ */
+
+ /* example:
+ * For example, given this as input:
+ * [["Title", "Year", "Producer"]
+ * ["Alien", "1979", "Ridley Scott"],
+ * ["Blade Runner", "1982", "Ridley Scott"]]
+ * We will return this as output:
+ * [{"Title":"Alien", "Year":"1979", "Producer":"Ridley Scott"},
+ * {"Title":"Blade Runner", "Year":"1982", "Producer":"Ridley Scott"}]
+ */
+ dojo.lang.assertType(arrayOfArrays, Array);
+ var arrayOfItems = [];
+ if (arrayOfArrays.length > 1) {
+ var arrayOfKeys = arrayOfArrays[0];
+ for (var i = 1; i < arrayOfArrays.length; ++i) {
+ var row = arrayOfArrays[i];
+ var item = {};
+ for (var j in row) {
+ var value = row[j];
+ var key = arrayOfKeys[j];
+ item[key] = value;
+ }
+ arrayOfItems.push(item);
+ }
+ }
+ return arrayOfItems; // Array
+ },
+
+ _getRemoteStoreDataFromArrayOfObjects: function(/* object[] */ arrayOfObjects) {
+ /* summary:
+ * Converts an array of keyword objects in the internal record data
+ * structure used by RemoteStore.
+ */
+
+ /* example:
+ * For example, given this as input:
+ * [{"Title":"Alien", "Year":"1979", "Producer":"Ridley Scott"},
+ * {"Title":"Blade Runner", "Year":"1982", "Producer":"Ridley Scott"}]
+ * We will return this as output:
+ * { "1": {"Title":["Alien"], "Year":["1979"], "Producer":["Ridley Scott"]},
+ * "2": {"Title":["Blade Runner"], "Year":["1982"], "Producer":["Ridley Scott"]}
+ * }
+ */
+ dojo.lang.assertType(arrayOfObjects, Array);
+ var output = {};
+ for (var i = 0; i < arrayOfObjects.length; ++i) {
+ var object = arrayOfObjects[i];
+ for (var key in object) {
+ var value = object[key]; // {"Title":"Alien"} --> "Alien"
+ object[key] = [value]; // {"Title":["Alien"]}
+ }
+ output[i] = object;
+ }
+ return output; // Object
+ },
+
+ // CsvStore implements the dojo.data.core.Read API, but does not yet
+ // implements the dojo.data.core.Write API. CsvStore extends RemoteStore,
+ // and RemoteStore does implement the Write API, so we need to explicitly
+ // mark those Write API methods as being unimplemented.
+ newItem: function(/* object? */ attributes, /* object? */ keywordArgs) {
+ dojo.unimplemented('dojo.data.CsvStore.newItem');
+ },
+ deleteItem: function(/* item */ item) {
+ dojo.unimplemented('dojo.data.CsvStore.deleteItem');
+ },
+ setValues: function(/* item */ item, /* attribute || string */ attribute, /* array */ values) {
+ dojo.unimplemented('dojo.data.CsvStore.setValues');
+ },
+ set: function(/* item */ item, /* attribute || string */ attribute, /* almost anything */ value) {
+ dojo.unimplemented('dojo.data.CsvStore.set');
+ },
+ unsetAttribute: function(/* item */ item, /* attribute || string */ attribute) {
+ dojo.unimplemented('dojo.data.CsvStore.unsetAttribute');
+ },
+ save: function(/* object? */ keywordArgs) {
+ dojo.unimplemented('dojo.data.CsvStore.save');
+ },
+ revert: function() {
+ dojo.unimplemented('dojo.data.CsvStore.revert');
+ },
+ isDirty: function(/*item?*/ item) {
+ dojo.unimplemented('dojo.data.CsvStore.isDirty');
+ }
+
+});
+
diff --git a/source/web/scripts/ajax/dojo/src/data/OpmlStore.js b/source/web/scripts/ajax/dojo/src/data/OpmlStore.js
new file mode 100644
index 0000000000..3b4904fe0d
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/OpmlStore.js
@@ -0,0 +1,224 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.OpmlStore");
+dojo.require("dojo.data.core.Read");
+dojo.require("dojo.data.core.Result");
+dojo.require("dojo.lang.assert");
+dojo.require("dojo.json");
+
+dojo.require("dojo.experimental");
+dojo.experimental("dojo.data.OpmlStore");
+// FIXME: The OpmlStore works in Firefox but does not yet work in IE.
+
+dojo.declare("dojo.data.OpmlStore", dojo.data.core.Read, {
+ /* summary:
+ * The OpmlStore implements the dojo.data.core.Read API.
+ */
+
+ /* examples:
+ * var opmlStore = new dojo.data.OpmlStore({url:"geography.opml"});
+ * var opmlStore = new dojo.data.OpmlStore({url:"http://example.com/geography.opml"});
+ */
+ initializer: function(/* object */ keywordParameters) {
+ // keywordParameters: {url: String}
+ this._arrayOfTopLevelItems = [];
+ this._metadataNodes = null;
+ this._loadFinished = false;
+ this._opmlFileUrl = keywordParameters["url"];
+ },
+
+ _assertIsItem: function(/* item */ item) {
+ if (!this.isItem(item)) {
+ throw new Error("dojo.data.OpmlStore: a function was passed an item argument that was not an item");
+ }
+ },
+
+ _removeChildNodesThatAreNotElementNodes: function(/* node */ node, /* boolean */ recursive) {
+ var childNodes = node.childNodes;
+ if (childNodes.length == 0) {
+ return;
+ }
+ var nodesToRemove = [];
+ var i, childNode;
+ for (i = 0; i < childNodes.length; ++i) {
+ childNode = childNodes[i];
+ if (childNode.nodeType != Node.ELEMENT_NODE) {
+ nodesToRemove.push(childNode);
+ }
+ };
+ // dojo.debug('trim: ' + childNodes.length + ' total, ' + nodesToRemove.length + ' junk');
+ for (i = 0; i < nodesToRemove.length; ++i) {
+ childNode = nodesToRemove[i];
+ node.removeChild(childNode);
+ }
+ // dojo.debug('trim: ' + childNodes.length + ' remaining');
+ if (recursive) {
+ for (i = 0; i < childNodes.length; ++i) {
+ childNode = childNodes[i];
+ this._removeChildNodesThatAreNotElementNodes(childNode, recursive);
+ }
+ }
+ },
+
+ _processRawXmlTree: function(/* xmlDoc */ rawXmlTree) {
+ var headNodes = rawXmlTree.getElementsByTagName('head');
+ var headNode = headNodes[0];
+ this._removeChildNodesThatAreNotElementNodes(headNode);
+ this._metadataNodes = headNode.childNodes;
+ var bodyNodes = rawXmlTree.getElementsByTagName('body');
+ var bodyNode = bodyNodes[0];
+ this._removeChildNodesThatAreNotElementNodes(bodyNode, true);
+
+ var bodyChildNodes = bodyNodes[0].childNodes;
+ for (var i = 0; i < bodyChildNodes.length; ++i) {
+ var node = bodyChildNodes[i];
+ if (node.tagName == 'outline') {
+ this._arrayOfTopLevelItems.push(node);
+ }
+ }
+ },
+
+ get: function(/* item */ item, /* attribute || attribute-name-string */ attribute, /* value? */ defaultValue) {
+ // summary: See dojo.data.core.Read.get()
+ this._assertIsItem(item);
+ if (attribute == 'children') {
+ return (item.firstChild || defaultValue);
+ } else {
+ var value = item.getAttribute(attribute);
+ value = (value != undefined) ? value : defaultValue;
+ return value;
+ }
+ },
+
+ getValues: function(/* item */ item, /* attribute || attribute-name-string */ attribute) {
+ // summary: See dojo.data.core.Read.getValues()
+ this._assertIsItem(item);
+ if (attribute == 'children') {
+ var array = [];
+ for (var i = 0; i < item.childNodes.length; ++i) {
+ array.push(item.childNodes[i]);
+ }
+ return array; // Array
+ // return item.childNodes; // FIXME: this isn't really an Array
+ } else {
+ return [item.getAttribute(attribute)]; // Array
+ }
+ },
+
+ getAttributes: function(/* item */ item) {
+ // summary: See dojo.data.core.Read.getAttributes()
+ this._assertIsItem(item);
+ var attributes = [];
+ var xmlNode = item;
+ var xmlAttributes = xmlNode.attributes;
+ for (var i = 0; i < xmlAttributes.length; ++i) {
+ var xmlAttribute = xmlAttributes.item(i);
+ attributes.push(xmlAttribute.nodeName);
+ }
+ if (xmlNode.childNodes.length > 0) {
+ attributes.push('children');
+ }
+ return attributes; // array
+ },
+
+ hasAttribute: function(/* item */ item, /* attribute || attribute-name-string */ attribute) {
+ // summary: See dojo.data.core.Read.hasAttribute()
+ return (this.getValues(item, attribute).length > 0);
+ },
+
+ containsValue: function(/* item */ item, /* attribute || attribute-name-string */ attribute, /* anything */ value) {
+ // summary: See dojo.data.core.Read.containsValue()
+ var values = this.getValues(item, attribute);
+ for (var i = 0; i < values.length; ++i) {
+ var possibleValue = values[i];
+ if (value == possibleValue) {
+ return true;
+ }
+ }
+ return false; // boolean
+ },
+
+ isItem: function(/* anything */ something) {
+ return (something &&
+ something.nodeType == Node.ELEMENT_NODE &&
+ something.tagName == 'outline'); // boolean
+ },
+
+ isItemAvailable: function(/* anything */ something) {
+ return this.isItem(something);
+ },
+
+ find: function(/* object? || dojo.data.core.Result */ keywordArgs) {
+ // summary: See dojo.data.core.Read.find()
+ var result = null;
+ if (keywordArgs instanceof dojo.data.core.Result) {
+ result = keywordArgs;
+ result.store = this;
+ } else {
+ result = new dojo.data.core.Result(keywordArgs, this);
+ }
+ var self = this;
+ var bindHandler = function(type, data, evt) {
+ var scope = result.scope || dj_global;
+ if (type == "load") {
+ self._processRawXmlTree(data);
+ if (result.saveResult) {
+ result.items = self._arrayOfTopLevelItems;
+ }
+ if (result.onbegin) {
+ result.onbegin.call(scope, result);
+ }
+ for (var i=0; i < self._arrayOfTopLevelItems.length; i++) {
+ var item = self._arrayOfTopLevelItems[i];
+ if (result.onnext && !result._aborted) {
+ result.onnext.call(scope, item, result);
+ }
+ }
+ if (result.oncompleted && !result._aborted) {
+ result.oncompleted.call(scope, result);
+ }
+ } else if(type == "error" || type == 'timeout') {
+ // todo: how to handle timeout?
+ var errorObject = data;
+ // dojo.debug("error in dojo.data.OpmlStore.find(): " + dojo.json.serialize(errorObject));
+ if (result.onerror) {
+ result.onerror.call(scope, data);
+ }
+ }
+ };
+
+ if (!this._loadFinished) {
+ if (this._opmlFileUrl) {
+ var bindRequest = dojo.io.bind({
+ url: this._opmlFileUrl, // "playlist.opml",
+ handle: bindHandler,
+ mimetype: "text/xml",
+ sync: (result.sync || false) });
+ result._abortFunc = bindRequest.abort;
+ }
+ }
+ return result; // dojo.data.csv.Result
+ },
+
+ getIdentity: function(/* item */ item) {
+ // summary: See dojo.data.core.Read.getIdentity()
+ dojo.unimplemented('dojo.data.OpmlStore.getIdentity()');
+ return null;
+ },
+
+ findByIdentity: function(/* string */ identity) {
+ // summary: See dojo.data.core.Read.findByIdentity()
+ dojo.unimplemented('dojo.data.OpmlStore.findByIdentity()');
+ return null;
+ }
+});
+
+
diff --git a/source/web/scripts/ajax/dojo/src/data/RdfStore.js b/source/web/scripts/ajax/dojo/src/data/RdfStore.js
new file mode 100644
index 0000000000..74c4751be7
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/RdfStore.js
@@ -0,0 +1,292 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.RdfStore");
+dojo.provide("dojo.data.RhizomeStore");
+dojo.require("dojo.lang.declare");
+dojo.require("dojo.data.core.RemoteStore");
+dojo.require("dojo.experimental");
+
+/* summary:
+ * RdfStore provides a dojo.data Store for querying and updating a server
+ * that supports the SPARQL Query Result JSON format.
+ * (see http://www.w3.org/TR/rdf-sparql-json-res/)
+ *
+ * It also maps RDF datatypes to Javascript objects.
+ *
+ * RdfStore makes following assumptions about the Result JSON:
+ * (1) The result always contains 3 bound variables named "s","p", and "o",
+ * and each result binding is treated as an RDF statement.
+ * (2) When saving changes to the store, the JSON "results" object will also
+ * contain a "deleted" key whose value is a list of deleted RDF resources.
+ *
+ */
+
+dojo.data.RdfDatatypeSerializer = function(/* JavaScript type */type, /* function */convertFunc, /* RDF datatype URI */uri) {
+ /* summary:
+ This class serializes a javascript object into a RDF datatype literal.
+ */
+ this.type = type;
+ this._converter = convertFunc;
+ this.uri = uri;
+ this.serialize = function(value) {
+ return this._converter.call(value, value);
+ };
+}
+
+dojo.declare("dojo.data.RdfStore", dojo.data.core.RemoteStore, {
+
+ _datatypeMap: {
+ //map datatype strings to constructor function
+ literal: function(value) {
+ var literal = value.value;
+ if (value["xml:lang"]) {
+ literal.lang = value["xml:lang"];
+ }
+ return literal;
+ },
+
+ uri: function(value) {
+ return { id: value.value };
+ },
+
+ bnode: function(value) {
+ return { id: '_:' + value.value };
+ },
+
+ 'http://www.w3.org/2001/XMLSchema#int': function(value) {
+ return parseInt(value.value);
+ },
+ 'http://www.w3.org/2001/XMLSchema#integer': function(value) {
+ return parseInt(value.value);
+ },
+ 'http://www.w3.org/2001/XMLSchema#long': function(value) {
+ return parseInt(value.value);
+ },
+ 'http://www.w3.org/2001/XMLSchema#float': function(value) {
+ return parseFloat(value.value);
+ },
+ 'http://www.w3.org/2001/XMLSchema#double': function(value) {
+ return parseFloat(value.value);
+ },
+ 'http://www.w3.org/2001/XMLSchema#boolean': function(value) {
+ return !value || value == "false" || value == "0" ? false : true;
+ }
+ //todo: more datatypes:
+ //integer subtypes, string types, XMLiteral
+ //,'http://www.w3.org/2001/XMLSchema#... : function(value) { return parseInt(value.value); }
+ },
+
+ _datatypeSerializers: [
+ new dojo.data.RdfDatatypeSerializer(Number, Number.toString, 'http://www.w3.org/2001/XMLSchema#float'),
+ new dojo.data.RdfDatatypeSerializer(Boolean, Boolean.toString, 'http://www.w3.org/2001/XMLSchema#boolean')
+ ],
+
+ _findDatatypeSerializer: function(value) {
+ var length = this._datatypeSerializers.length;
+ for (var i = 0; i < length; i++) {
+ var datatype = this._datatypeSerializers[i];
+ if (value instanceof datatype.type) {
+ return datatype;
+ }
+ }
+ },
+
+ _toRDFValue: function(value) {
+ //convert values to rdf json format
+ //(from http://www.w3.org/TR/2006/NOTE-rdf-sparql-json-res-20061004/)
+
+ var rdfvalue = {};
+ if (value.id) {
+ if (value.id.slice(0, 2) == '_:') {
+ rdfvalue.type = 'bnode';
+ rdfvalue.value = value.id.substring(2);
+ } else {
+ rdfvalue.type = 'uri';
+ rdfvalue.value = value.id;
+ }
+ } else if (typeof value == "string" || value instanceof String) {
+ rdfvalue.type = 'literal';
+ rdfvalue.value = value;
+ if (value.lang)
+ rdfvalue["xml:lang"] = value.lang;
+ } else {
+ if (typeof value == "number")
+ value = new Number(value);
+ else if (typeof value == "boolean")
+ value = new Boolean(value);
+
+ var datatype = this._findDatatypeSerializer(value);
+ if (datatype) {
+ rdfvalue = {
+ "type": "typed-literal",
+ "datatype": datatype.uri,
+ "value": value.toString()
+ //todo: datatype.serialize(value) causes
+ //Error: Function.prototype.toString called on incompatible number
+ };
+ } else {
+ //treat it as a string
+ //todo: warn?
+ rdfvalue = {
+ "type": "literal",
+ "value": value.toString() };
+ }
+ }
+ return rdfvalue;
+ },
+
+ _setupSaveRequest: function(saveKeywordArgs, requestKw) {
+ /*
+ This function prepares the save request by populating requestKw,
+ an associative array that will be passed to dojo.io.bind.
+ */
+
+ //see http://www.w3.org/TR/rdf-sparql-json-res/
+ var rdfResult = { "head": {'vars': ['s','p','o']},
+ "results": {'bindings': []} };
+
+ var resources = [];
+ for (var key in this._deleted) {
+ resources.push(key);
+ }
+ rdfResult.results.deleted = resources;
+
+ for (key in this._changed) {
+ var subject = this._toRDFValue(this.getIdentity(key))
+
+ var attributes = this._changed[key];
+ for (var attr in attributes) {
+ var predicate = {type:'uri', value: attr};
+
+ var values = attributes[attr];
+ if (!values.length)
+ continue;
+ var rdfvalues = [];
+ for (var i = 0; i < values.length; i++) {
+ var rdfvalue = this._toRDFValue(values[i]);
+ rdfResult.results.bindings.push(
+ {s: subject, p: predicate, o: rdfvalue});
+ }
+ }
+ }
+
+ var oldRegistry = dojo.json.jsonRegistry;
+ dojo.json.jsonRegistry = this._jsonRegistry;
+ var jsonString = dojo.json.serialize(rdfResult);
+ dojo.json.jsonRegistry = oldRegistry;
+
+ //dojo.debug('save json' , jsonString);
+
+ requestKw.postContent = jsonString;
+ },
+
+ _resultToQueryMetadata: function(json) {
+ return json.head;
+ },
+
+ _resultToQueryData: function(json) {
+ //assume s, p, o bindings
+ var items = {};
+ var stmts = json.results.bindings;
+ for (var i = 0; i < stmts.length; i++) {
+ var stmt = stmts[i];
+ //assert stmt.s && stmt.p && stmt.o;
+ var subject = stmt.s.value;
+ if (stmt.s.type == 'bnode') {
+ subject = '_:' + subject;
+ }
+ //else { assert stmt.s.type == 'uri';}
+ var attributes = data[subject];
+ if (!attributes) {
+ attributes = {};
+ data[stmt.s] = attributes;
+ }
+ var attr = attributes[stmt.p.value];
+ if (!attr) {
+ attributes[stmt.p.value] = [stmt.o];
+ } else {
+ attr.push(stmt.o);
+ }
+ }
+ return items;
+ }
+});
+
+dojo.declare("dojo.data.RhizomeStore", dojo.data.RdfStore, {
+ /* summary:
+ * RhizomeStore is a subclass of RdfStore that works with
+ * the Rhizome semantic wiki (see http://www.liminalzone.org)
+ * Rhizome understands the RemoteStore's "native" json format
+ * so it doesn't need to convert it to the SPARQL Query Result format.
+ */
+
+ initializer: function(kwArgs) {
+ this._serverQueryUrl = kwArgs.baseUrl + 'search?view=json&searchType=RxPath&search=';
+ this._serverSaveUrl = kwArgs.baseUrl + 'save-metadata';
+ },
+
+ _resultToQueryMetadata: function(json) {
+ return json;
+ },
+
+ _resultToQueryData: function(json) {
+ //dojo.debug( 'resultjson ' + dojo.json.serialize(json) );
+ return json;
+ },
+
+ _setupSaveRequest: function(saveKeywordArgs, requestKw) {
+ /*
+ This function prepares the save request by populating requestKw,
+ an associative array that will be passed to dojo.io.bind.
+ */
+ requestKw.url = this._serverSaveUrl;
+ requestKw.method = 'post';
+ requestKw.mimetype = "text/plain";
+
+ var resources = [];
+ for (var key in this._deleted) {
+ resources.push(key);
+ }
+
+ var changes = {};
+ for (key in this._changed) {
+ if (!this._added[key]) { //don't put new resources in this list
+ resources.push(key);
+ }
+
+ var attributes = this._changed[key];
+ var rdfattributes = {};
+ for (var attr in attributes) {
+ var values = attributes[attr];
+ if (!values.length)
+ continue;
+ var rdfvalues = [];
+ for (var i = 0; i < values.length; i++) {
+ var rdfvalue = this._toRDFValue(values[i]);
+ rdfvalues.push(rdfvalue);
+ }
+ rdfattributes[attr] = rdfvalues;
+ }
+ changes[key] = rdfattributes;
+ }
+
+ var oldRegistry = dojo.json.jsonRegistry;
+ dojo.json.jsonRegistry = this._jsonRegistry;
+ var jsonString = dojo.json.serialize(changes);
+ dojo.json.jsonRegistry = oldRegistry;
+
+ requestKw.content = {
+ rdfFormat: 'json',
+ resource: resources,
+ metadata: jsonString
+ };
+ }
+});
diff --git a/source/web/scripts/ajax/dojo/src/data/YahooStore.js b/source/web/scripts/ajax/dojo/src/data/YahooStore.js
new file mode 100644
index 0000000000..52ad0cdfeb
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/YahooStore.js
@@ -0,0 +1,53 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.YahooStore");
+dojo.require("dojo.data.core.RemoteStore");
+dojo.require("dojo.lang.declare");
+dojo.require("dojo.io.ScriptSrcIO");
+
+dojo.declare("dojo.data.YahooStore", dojo.data.core.RemoteStore, {
+ /* Summary:
+ * The YahooStore implements the dojo.data.core.Read API.
+ */
+ _setupQueryRequest: function(result, requestKw) {
+ var start = 1;
+ var count = 1;
+ if (result) {
+ start = result.start || start;
+ count = result.count || count;
+ }
+ var sourceUrl = "http://api.search.yahoo.com/WebSearchService/V1/webSearch?appid=dojo&language=en&query=" +
+ result.query + "&start=" + start + "&results=" + count + "&output=json";
+ requestKw.url = sourceUrl;
+ requestKw.transport = "ScriptSrcTransport";
+ requestKw.mimetype = "text/json";
+ requestKw.jsonParamName = 'callback';
+ },
+
+ _resultToQueryMetadata: function(json) {
+ return json.ResultSet;
+ },
+
+ _resultToQueryData: function(json) {
+ var data = {}
+ for (var i = 0; i < json.ResultSet.totalResultsReturned; ++i) {
+ var record = json.ResultSet.Result[i];
+ var item = {};
+ item["Url"] = [record.Url];
+ item["Title"] = [record.Title];
+ item["Summary"] =[ record.Summary];
+ var arrayIndex = (json.ResultSet.firstResultPosition - 1) + i;
+ data[ arrayIndex.toString() ] = item;
+ }
+ return data;
+ }
+});
+
diff --git a/source/web/scripts/ajax/dojo/src/data/core/Read.js b/source/web/scripts/ajax/dojo/src/data/core/Read.js
new file mode 100644
index 0000000000..f687e2ebef
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/core/Read.js
@@ -0,0 +1,321 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.core.Read");
+dojo.require("dojo.data.core.Result");
+dojo.require("dojo.lang.declare");
+dojo.require("dojo.experimental");
+
+/* summary:
+ * This is an abstract API that data provider implementations conform to.
+ * This file defines methods signatures and intentionally leaves all the
+ * methods unimplemented.
+ */
+dojo.experimental("dojo.data.core.Read");
+
+dojo.declare("dojo.data.core.Read", null, {
+ get: function(/* item */ item, /* attribute || attribute-name-string */ attribute, /* value? */ defaultValue) {
+ /* summary:
+ * Returns a single attribute value.
+ * Returns defaultValue if *item* does not have a value for *attribute*.
+ * Returns null if null was explicitly set as the attribute value.
+ * Returns undefined if the item does not have a value for the given
+ * attribute, or if the item does not have the attribute.
+ * description:
+ * Saying that an "item x does not have a value for an attribute y"
+ * is identical to saying that an "item x does not have attribute y".
+ * It is an oxymoron to say "that attribute is present but has no values"
+ * or "the item has that attribute but does not have any attribute values".
+ * If store.hasAttribute(item, attribute) returns false, then
+ * store.get(item, attribute) will return undefined.
+ */
+
+ /* exceptions:
+ * Conforming implementations should throw an exception if *item* is not
+ * an item, or *attribute* is neither an attribute object or a string.
+ * examples:
+ * var darthVader = store.get(lukeSkywalker, "father");
+ */
+ dojo.unimplemented('dojo.data.core.Read.get');
+ var attributeValue = null;
+ return attributeValue; // a literal, an item, null, or undefined (never an array)
+ },
+
+ getValues: function(/* item */ item, /* attribute || attribute-name-string */ attribute) {
+ /* summary:
+ * This getValues() method works just like the get() method, but getValues()
+ * always returns an array rather than a single attribute value. The array
+ * may be empty, may contain a single attribute value, or may contain many
+ * attribute values.
+ * If the item does not have a value for the given attribute, then getValues()
+ * will return an empty array: []. (So, if store.hasAttribute(item, attribute)
+ * returns false, then store.getValues(item, attribute) will return [].)
+ */
+
+ /* exceptions:
+ * Throws an exception if *item* is not an item, or *attribute* is neither an
+ * attribute object or a string.
+ * examples:
+ * var friendsOfLuke = store.get(lukeSkywalker, "friends");
+ */
+ dojo.unimplemented('dojo.data.core.Read.getValues');
+ var array = null;
+ return array; // an array that may contain literals and items
+ },
+
+ getAttributes: function(/* item */ item) {
+ /* summary:
+ * Returns an array with all the attributes that this item has. This
+ * method will always return an array; if the item has no attributes
+ * at all, getAttributes() will return an empty array: [].
+ */
+
+ /* exceptions:
+ * Throws an exception if *item* is not an item.
+ * examples:
+ * var array = store.getAttributes(kermit);
+ */
+ dojo.unimplemented('dojo.data.core.Read.getAttributes');
+ var array = null;
+ return array; // array
+ },
+
+ hasAttribute: function(/* item */ item, /* attribute || attribute-name-string */ attribute) {
+ /* summary:
+ * Returns true if the given *item* has a value for the given *attribute*.
+ */
+
+ /* exceptions:
+ * Throws an exception if *item* is not an item, or *attribute* is neither an
+ * attribute object or a string.
+ * examples:
+ * var trueOrFalse = store.hasAttribute(kermit, "color");
+ */
+ dojo.unimplemented('dojo.data.core.Read.hasAttribute');
+ return false; // boolean
+ },
+
+ containsValue: function(/* item */ item, /* attribute || attribute-name-string */ attribute, /* anything */ value) {
+ /* summary:
+ * Returns true if the given *value* is one of the values that getValue()
+ * would return.
+ */
+
+ /* exceptions:
+ * Throws an exception if *item* is not an item, or *attribute* is neither an
+ * attribute object or a string.
+ * examples:
+ * var trueOrFalse = store.containsValue(kermit, "color", "green");
+ */
+ dojo.unimplemented('dojo.data.core.Read.containsValue');
+ return false; // boolean
+ },
+
+ isItem: function(/* anything */ something) {
+ /* summary:
+ * Returns true if *something* is an item. Returns false if *something*
+ * is a literal or is any object other than an item.
+ */
+
+ /* examples:
+ * var yes = store.isItem(store.newItem());
+ * var no = store.isItem("green");
+ */
+ dojo.unimplemented('dojo.data.core.Read.isItem');
+ return false; // boolean
+ },
+
+ isItemAvailable: function(/* anything */ something) {
+ /* summary:
+ * Returns false if isItem(something) is false. Returns false if
+ * if isItem(something) is true but the the item is not yet available
+ * in local memory (for example, if the item has not yet been fully
+ * loaded from the server).
+ */
+
+ /* examples:
+ * var yes = store.isItemAvailable(store.newItem());
+ * var no = store.isItemAvailable("green");
+ */
+ dojo.unimplemented('dojo.data.core.Read.isItemAvailable');
+ return false; // boolean
+ },
+
+ find: function(/* object? || dojo.data.core.Result */ keywordArgs) {
+ /* summary:
+ * Given a query, this method executes the query and makes the
+ * results available as data items.
+ * description:
+ * A Result object will always be returned, even if the result set
+ * is empty. A Result object will always be returned immediately.
+ * By default the Result object will be fully populated with result
+ * items as soon as it is created (synchronously). The caller may
+ * request that the find() operation be executed asynchronously, in
+ * which case the Result object will be returned immediately but
+ * will not yet be populated with result items.
+ * For more info about the Result API, see dojo.data.core.Result
+ * keywordArgs:
+ * The keywordArgs parameter may either be an instance of
+ * dojo.data.core.Result or may be a simple anonymous object
+ * that may contain any of the following:
+ * { query: query-string or query-object,
+ * sync: Boolean,
+ * saveResult: Boolean,
+ * onbegin: Function,
+ * onnext: Function,
+ * oncompleted: Function,
+ * onerror: Function,
+ * scope: object
+ * }
+ * All implementations should accept keywordArgs objects with any of
+ * the 7 standard properties: query, sync, saveResult, onnext, oncompleted,
+ * onerror, and scope. Some implementations may accept additional
+ * properties in the keywordArgs object as valid parameters, such as
+ * {maxResults:100} or {includeOutliers:true}.
+ * The *query* parameter.
+ * The query may be optional in some data store implementations.
+ * The dojo.data.core.Read API does not specify the syntax or semantics
+ * of the query itself -- each different data store implementation
+ * may have its own notion of what a query should look like.
+ * In most implementations the query will probably be a string, but
+ * in some implementations the query might be a Date, or a number,
+ * or some complex keyword parameter object. The dojo.data.core.Read
+ * API is completely agnostic about what the query actually is.
+ * The *sync* parameter.
+ * The sync parameter specifies whether the find operation is asynchronous
+ * or not, with {sync:false} for asynchronous finds operations and
+ * {sync:true} for synchronous find operations. If no sync parameter
+ * is specified, the default is {sync:true}.
+ * The *saveResult* parameter.
+ * If saveResult is true, then the find call will return a Result
+ * object that includes a property called *items*, and *items* will
+ * contain an array of the items found by the query. If no saveResult
+ * parameter is specified and no onnext Function is set, the default
+ * saveResult value will be {saveResult:true}. If no saveResult
+ * parameter is specified but an onnext Function is set, the default
+ * saveResult value will be {saveResult:false}.
+ * The *onbegin* parameter.
+ * If an onbegin callback function is provided, the callback function
+ * will be called just once, before the first onnext callback is called.
+ * The onbegin callback function will be passed a single argument:
+ * the Result object. The onbegin callback will be called even if
+ * query returns zero items.
+ * The *onnext* parameter.
+ * If an onnext callback function is provided, the callback function
+ * will be called as each item in the result is received. The callback
+ * function will be passed two arguments: the item itself, and the
+ * Result object.
+ * The *oncompleted* parameter.
+ * If an oncompleted callback function is provided, the callback function
+ * will be called just once, after the last onnext callback is called.
+ * The oncompleted callback function will be passed a single argument:
+ * the Result object. The oncompleted callback will be called even if
+ * query returns zero items.
+ * The *onerror* parameter.
+ * If an onerror callback function is provided, the callback function
+ * will be called if there is any sort of error while attempting to
+ * execute the query..
+ * The onerror callback function will be passed two arguments:
+ * an Error object and the Result object.
+ * The *scope* parameter.
+ * If a scope object is provided, all of the callback function (onnext,
+ * oncompleted, onerror) will be invoked in the context of the scope
+ * object. In the body of the callback function, the value of the "this"
+ * keyword will be the scope object. If no scope object is provided,
+ * the callback functions will be called in the context of dj_global.
+ * For example, onnext.call(scope, item, result) vs.
+ * onnext.call(dj_global, item, result)
+ * returns:
+ * The find() method will return an instance of dojo.data.core.Result
+ * (or an object that extends dojo.data.core.Result or conforms to the
+ * dojo.data.core.Result API). If the find() method was passed an
+ * instance of dojo.data.core.Result as an argument, the same instance
+ * will be returned. If the find() method was passed a simple
+ * keywordArgs object, like {sync:true}, then the properties in the
+ * keywordArgs object will be copied into the Result object that
+ * find() returns. The Result object will also have additional
+ * properties when it is returned. The result.store property will
+ * have a pointer to the datastore object that find() is a method of.
+ * The result.length will be -1 if the find() operation has not
+ * finished or if there was an error; if the find() operation
+ * finishes successfully, result.length will be the number of items
+ * that were found. If the saveResult property was set to true, or
+ * if no onnext callback was set, the result.item property will
+ * contain an array of data items. The result.resultMetadata property
+ * will contain an additional metaData that was returned by the query
+ * along with the data items. For example, if the query returned a
+ * list of 500 houses for sales, the resultMetadata property might
+ * contain the average asking price of the houses, or info about
+ * how long the query took to execute.
+ */
+
+ /* exceptions:
+ * Throws an exception if the query is not valid, or if the query
+ * is required but was not supplied.
+ * examples:
+ * var result = store.find({query:"all books"});
+ * var result = store.find();
+ * var result = store.find({query:"foo/bar", sync:true});
+ * var result = store.find({query:"foo/bar", sync:false, onnext:callback});
+ * var result = store.find({query:{author:"King"}, maxResults:100});
+ */
+ dojo.unimplemented('dojo.data.core.Read.find');
+ var result = null; // new dojo.data.core.Result().
+ return result; // a dojo.data.core.Result object
+ },
+
+ getIdentity: function(/* item */ item) {
+ /* summary:
+ * Returns a unique identifer for an item. The return value will be
+ * either a string or something that has a toString() method (such as,
+ * for example, a dojo.uuid.Uuid object).
+ * description:
+ * ISSUE -
+ * Should we move this method out of dojo.data.core.Read, and put it somewhere
+ * else, like maybe dojo.data.core.Identity?
+ */
+
+ /* exceptions:
+ * Conforming implementations may throw an exception or return null if
+ * item is not an item.
+ * examples:
+ * var itemId = store.getIdentity(kermit);
+ * assert(kermit === store.findByIdentity(store.getIdentity(kermit)));
+ */
+ dojo.unimplemented('dojo.data.core.Read.getIdentity');
+ var itemIdentifyString = null;
+ return itemIdentifyString; // string
+ },
+
+ findByIdentity: function(/* string */ identity) {
+ /* summary:
+ * Given the identity of an item, this method returns the item that has
+ * that identity. Conforming implementations should return null if there
+ * is no item with the given identity. Implementations of findByIdentity()
+ * may sometimes return an item from a local cache and may sometimes
+ * fetch an item from a remote server, in which case the call to
+ * findByIdentity() will block until the findByIdentity() implementation
+ * has the item to return.
+ * description:
+ * FIXME -
+ * In our meeting on 2006-10-03 we resolved to move the findByIdentity()
+ * method out of the Read.js API and into the Identity.js API, as soon
+ * as we have an Identity.js API.
+ */
+
+ /* examples:
+ * var alaska = store.getByIdentity("AK");
+ * assert("AK" == store.getIdentity(store.getByIdentity("AK")));
+ */
+ dojo.unimplemented('dojo.data.core.Read.getByIdentity');
+ var item = null;
+ return item; // item
+ }
+});
diff --git a/source/web/scripts/ajax/dojo/src/data/core/RemoteStore.js b/source/web/scripts/ajax/dojo/src/data/core/RemoteStore.js
new file mode 100644
index 0000000000..2a4c2db88d
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/core/RemoteStore.js
@@ -0,0 +1,590 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.core.RemoteStore");
+dojo.require("dojo.data.core.Read");
+dojo.require("dojo.data.core.Write");
+dojo.require("dojo.data.core.Result");
+dojo.require("dojo.experimental");
+dojo.require("dojo.Deferred");
+dojo.require("dojo.lang.declare");
+dojo.require("dojo.json");
+dojo.require("dojo.io.*");
+
+/* summary:
+ * RemoteStore is an implemention the dojo.data.core.Read and Write APIs.
+ * It is designed to serve as a base class for dojo.data stores which interact
+ * with stateless web services that can querying and modifying record-oriented
+ * data. Its features include asynchronous and synchronous querying and saving;
+ * caching of queries; transactions; and datatype mapping.
+ */
+
+/**************************************************************************
+ Classes derived from RemoteStore should implement the following three
+ methods, which are each described in the documentation below:
+ _setupQueryRequest(result, requestKw)
+ _resultToQueryData(responseData)
+ _setupSaveRequest(saveKeywordArgs, requestKw)
+
+ Data Consistency Guarantees
+
+ * if two references to the same item are obtained (e.g. from two different query results) any changes to one item will be reflected in the other item reference.
+ * If an item has changed on the server and the item is retrieved via a new query, any previously obtained references to the item will (silently) reflect these new values.
+ * However, any uncommitted changes will not be "overwritten".
+ * If server queries are made while there are uncommitted changes, no attempt is made to evaluate whether the modifications would change the query result, e.g. add any uncommitted new items that match the query.
+ * However, uncomitted deleted items are removed from the query result.
+ * The transaction isolation level is equivalent to JDBC's "Read Committed":
+ each store instance is treated as separate transaction; since there is no row or table locking so nonrepeatable and phantom reads are possible.
+
+ Memory Usage
+
+ Because Javascript doesn't support weak references or user-defined finalize methods, there is a tradeoff between data consistency and memory usage.
+ In order to implement the above consistency guarantees (and to provide caching), RemoteStore remembers all the queries and items retrieved.
+ To reduce memory consumption, use the method forgetResults(query);
+
+ Store assumptions
+
+ RemoteStore makes some assumptions about the nature of the remote store, things may break if these aren't true:
+ * that the items contained in a query response include all the attributes of the item (e.g. all the columns of a row).
+ (to fix: changes need to record add and removes and fix self._data[key] = [ attributeDict, refCount]; )
+ * the query result may contain references to items that are not available to the client; use isItem() to test for the presence of the item.
+ * that modification to an item's attributes won't change it's primary key.
+
+**************************************************************************/
+
+/* dojo.data API issues to resolve:
+ * save should returns a Deferred, might want to add keyword argument with 'sync'
+ */
+
+dojo.experimental("dojo.data.core.RemoteStore");
+
+dojo.lang.declare("dojo.data.core.RemoteStore", [dojo.data.core.Read, dojo.data.core.Write], {
+
+ _datatypeMap: {
+ //map datatype strings to constructor function
+ },
+
+ //set to customize json serialization
+ _jsonRegistry: dojo.json.jsonRegistry,
+
+ initializer: function(/* object */ kwArgs) {
+ if (!kwArgs) {
+ kwArgs = {};
+ }
+ this._serverQueryUrl = kwArgs.queryUrl || "";
+ this._serverSaveUrl = kwArgs.saveUrl || "";
+
+ this._deleted = {}; // deleted items {id: 1}
+ this._changed = {}; // {id: {attr: [new values]}} // [] if attribute is removed
+ this._added = {}; // {id: 1} list of added items
+ this._results = {}; // {query: [ id1, ]}; // todo: make MRUDict of queries
+ /* data is a dictionary that conforms to this format:
+ { id-string: { attribute-string: [ value1, value2 ] } }
+ where value is either an atomic JSON data type or
+ { 'id': string } for references to items
+ or
+ { 'type': 'name', 'value': 'value' } for user-defined datatypes
+ */
+ this._data = {}; // {id: [values, refcount]} // todo: handle refcount
+ this._numItems = 0;
+ },
+
+ _setupQueryRequest: function(/* dojo.data.core.Result */ result, /* object */ requestKw) {
+ /* summary:
+ * Classes derived from RemoteStore should override this method to
+ * provide their own implementations.
+ * This function prepares the query request by populating requestKw,
+ * an associative array that will be passed to dojo.io.bind.
+ */
+ result.query = result.query || "";
+ requestKw.url = this._serverQueryUrl + encodeURIComponent(result.query);
+ requestKw.method = 'get';
+ requestKw.mimetype = "text/json";
+ },
+
+ _resultToQueryMetadata: function(/* varies */ serverResponseData) {
+ /* summary:
+ * Classes derived from RemoteStore should override this method to
+ * provide their own implementations.
+ * Converts the server response data into the resultMetadata object
+ * that will be returned to the caller.
+ * returns:
+ * This simple default implementation just returns the entire raw
+ * serverResponseData, allowing the caller complete access to the
+ * raw response data and metadata.
+ */
+ return serverResponseData;
+ },
+
+ _resultToQueryData: function(/* varies */ serverResponseData) {
+ /* summary:
+ * Classes derived from RemoteStore should override this method to
+ * provide their own implementations.
+ * Converts the server response data into the internal data structure
+ * used by RemoteStore.
+ * returns:
+ * The RemoteStore implementation requires _resultToQueryData() to
+ * return an object that looks like:
+ * {item1-identifier-string: {
+ * attribute1-string: [ value1, value2, ... ],
+ * attribute2-string: [ value3, value4, ... ],
+ * ...
+ * },
+ * item2-identifier-string: {
+ * attribute1-string: [ value10, value11, ... ],
+ * attribute2-string: [ value12, value13, ... ],
+ * ...
+ * }
+ * }
+ * where value is either an atomic JSON data type or
+ * {'id': string } for references to items
+ * or
+ * {'type': 'name', 'value': 'value' } for user-defined datatypes
+ * data:
+ * This simple default implementation assumes that the *serverResponseData*
+ * argument is an object that looks like:
+ * { data:{ ... }, format:'format identifier', other metadata }
+ *
+ */
+ return serverResponseData.data;
+ },
+
+ _remoteToLocalValues: function(/* object */ attributes) {
+ for (var key in attributes) {
+ var values = attributes[key];
+ for (var i = 0; i < values.length; i++) {
+ var value = values[i];
+ var type = value.datatype || value.type;
+ if (type) {
+ // todo: better error handling?
+ var localValue = value.value;
+ if (this._datatypeMap[type])
+ localValue = this._datatypeMap[type](value);
+ values[i] = localValue;
+ }
+ }
+ }
+ return attributes; // object (attributes argument, modified in-place)
+ },
+
+ _queryToQueryKey: function(query) {
+ /* summary:
+ * Convert the query to a string that uniquely represents this query.
+ * (Used by the query cache.)
+ */
+ if (typeof query == "string")
+ return query;
+ else
+ return dojo.json.serialize(query);
+ },
+
+ _assertIsItem: function(/* item */ item) {
+ if (!this.isItem(item)) {
+ throw new Error("dojo.data.RemoteStore: a function was passed an item argument that was not an item");
+ }
+ },
+
+ get: function(/* item */ item, /* attribute || string */ attribute, /* value? */ defaultValue) {
+ // summary: See dojo.data.core.Read.get()
+ var valueArray = this.getValues(item, attribute);
+ if (valueArray.length == 0) {
+ return defaultValue;
+ }
+ return valueArray[0]; // value
+ },
+
+ getValues: function(/* item */ item, /* attribute || string */ attribute) {
+ // summary: See dojo.data.core.Read.getValues()
+ var itemIdentity = this.getIdentity(item);
+ this._assertIsItem(itemIdentity);
+ var changes = this._changed[itemIdentity];
+ if (changes) {
+ var newvalues = changes[attribute];
+ if (newvalues !== undefined) {
+ return newvalues; // Array
+ }
+ else {
+ return []; // Array
+ }
+ }
+ // return item.atts[attribute];
+ return this._data[itemIdentity][0][attribute]; // Array
+ },
+
+ getAttributes: function(/* item */ item) {
+ // summary: See dojo.data.core.Read.getAttributes()
+ var itemIdentity = this.getIdentity(item);
+ if (!itemIdentity)
+ return undefined; //todo: raise exception
+
+ var atts = [];
+ //var attrDict = item.attrs;
+ var attrDict = this._data[itemIdentity][0];
+ for (var att in attrDict) {
+ atts.push(att);
+ }
+ return atts; // Array
+ },
+
+ hasAttribute: function(/* item */ item, /* attribute || string */ attribute) {
+ // summary: See dojo.data.core.Read.hasAttribute()
+ var valueArray = this.getValues(item, attribute);
+ return valueArray.length ? true : false; // Boolean
+ },
+
+ containsValue: function(/* item */ item, /* attribute || string */ attribute, /* value */ value) {
+ // summary: See dojo.data.core.Read.containsValue()
+ var valueArray = this.getValues(item, attribute);
+ for (var i=0; i < valueArray.length; i++) {
+ if (valueArray[i] == value) {
+ return true; // Boolean
+ }
+ }
+ return false; // Boolean
+ },
+
+ isItem: function(/* anything */ something) {
+ // summary: See dojo.data.core.Read.isItem()
+ if (!something) { return false; }
+ var itemIdentity = something;
+ // var id = something.id ? something.id : something;
+ // if (!id) { return false; }
+ if (this._deleted[itemIdentity]) { return false; } //todo: do this?
+ if (this._data[itemIdentity]) { return true; }
+ if (this._added[itemIdentity]) { return true; }
+ return false; // Boolean
+ },
+
+ find: function(/* object? || dojo.data.core.Result */ keywordArgs) {
+ // summary: See dojo.data.core.Read.find()
+ /* description:
+ * In addition to the keywordArgs parameters described in the
+ * dojo.data.core.Read.find() documentation, the keywordArgs for
+ * the RemoteStore find() method may include a bindArgs parameter,
+ * which the RemoteStore will pass to dojo.io.bind when it sends
+ * the query. The bindArgs parameter should be a keyword argument
+ * object, as described in the dojo.io.bind documentation.
+ */
+ var result = null;
+ if (keywordArgs instanceof dojo.data.core.Result) {
+ result = keywordArgs;
+ result.store = this;
+ } else {
+ result = new dojo.data.core.Result(keywordArgs, this);
+ }
+ var query = result.query;
+
+ //todo: use this._results to implement caching
+ var self = this;
+ var bindfunc = function(type, data, evt) {
+ var scope = result.scope || dj_global;
+ if(type == "load") {
+ //dojo.debug("loaded 1 " + dojo.json.serialize(data) );
+ result.resultMetadata = self._resultToQueryMetadata(data);
+ var dataDict = self._resultToQueryData(data);
+ //dojo.debug("loaded 2 " + dojo.json.serialize(dataDict) );
+ if (result.onbegin) {
+ result.onbegin.call(scope, result);
+ }
+ var count = 0;
+ var resultData = [];
+ var newItemCount = 0;
+ for (var key in dataDict) {
+ if (result._aborted) {
+ break;
+ }
+ if (!self._deleted[key]) { //skip deleted items
+ //todo if in _added, remove from _added
+ var values = dataDict[key];
+ var attributeDict = self._remoteToLocalValues(values);
+ var existingValue = self._data[key];
+ var refCount = 1;
+ if (existingValue) {
+ refCount = ++existingValue[1]; //increment ref count
+ } else {
+ newItemCount++;
+ }
+ //note: if the item already exists, we replace the item with latest set of attributes
+ //this assumes queries always return complete records
+ self._data[key] = [ attributeDict, refCount];
+ resultData.push(key);
+ count++;
+ if (result.onnext) {
+ result.onnext.call(scope, key, result);
+ }
+ }
+ }
+ self._results[self._queryToQueryKey(query)] = resultData;
+ self._numItems += newItemCount;
+
+ result.length = count;
+ if (result.saveResult) {
+ result.items = resultData;
+ }
+ if (!result._aborted && result.oncompleted) {
+ result.oncompleted.call(scope, result);
+ }
+ } else if(type == "error" || type == 'timeout') {
+ // here, "data" is our error object
+ //todo: how to handle timeout?
+ dojo.debug("find error: " + dojo.json.serialize(data));
+ if (result.onerror) {
+ result.onerror.call(scope, data);
+ }
+ }
+ };
+
+ var bindKw = keywordArgs.bindArgs || {};
+ bindKw.sync = result.sync;
+ bindKw.handle = bindfunc;
+
+ this._setupQueryRequest(result, bindKw);
+ var request = dojo.io.bind(bindKw);
+ //todo: error if not bind success
+ //dojo.debug( "bind success " + request.bindSuccess);
+ result._abortFunc = request.abort;
+ return result;
+ },
+
+ getIdentity: function(item) {
+ // summary: See dojo.data.core.Read.getIdentity()
+ if (!this.isItem(item)) {
+ return null;
+ }
+ return (item.id ? item.id : item); // Identity
+ },
+
+/*
+ findByIdentity: function(id) {
+ var item = this._latestData[id];
+ var idQuery = "/" + "*[.='"+id+"']";
+ //if (!item) item = this.find(idQuery, {async=0}); //todo: support bind(async=0)
+ if (item)
+ return new _Item(id, item, this);
+ return null;
+ },
+*/
+
+/****
+Write API
+***/
+ newItem: function(/* object? */ attributes, /* object? */ keywordArgs) {
+ var itemIdentity = keywordArgs['identity'];
+ if (this._deleted[itemIdentity]) {
+ delete this._deleted[itemIdentity];
+ } else {
+ this._added[itemIdentity] = 1;
+ //todo? this._numItems++; ?? but its not in this._data
+ }
+ if (attributes) {
+ // FIXME:
+ for (var attribute in attributes) {
+ var valueOrArrayOfValues = attributes[attribute];
+ if (dojo.lang.isArray(valueOrArrayOfValues)) {
+ this.setValues(itemIdentity, attribute, valueOrArrayOfValues);
+ } else {
+ this.set(itemIdentity, attribute, valueOrArrayOfValues);
+ }
+ }
+ }
+ return { id: itemIdentity };
+ },
+
+ deleteItem: function(/* item */ item) {
+ var identity = this.getIdentity(item);
+ if (!identity) {
+ return false;
+ }
+
+ if (this._added[identity]) {
+ delete this._added[identity];
+ } else {
+ this._deleted[identity] = 1;
+ //todo? this._numItems--; ?? but its still in this._data
+ }
+
+ if (this._changed[identity]) {
+ delete this._changed[identity];
+ }
+ return true;
+ },
+
+ setValues: function(/* item */ item, /* attribute || string */ attribute, /* array */ values) {
+ var identity = this.getIdentity(item);
+ if (!identity) {
+ return undefined; //todo: raise exception
+ }
+
+ var changes = this._changed[identity];
+ if (!changes) {
+ changes = {}
+ this._changed[identity] = changes;
+ }
+ changes[attribute] = values;
+ return true; // boolean
+ },
+
+ set: function(/* item */ item, /* attribute || string */ attribute, /* almost anything */ value) {
+ return this.setValues(item, attribute, [value]);
+ },
+
+ unsetAttribute: function(/* item */ item, /* attribute || string */ attribute) {
+ return this.setValues(item, attribute, []);
+ },
+
+ _initChanges: function() {
+ this._deleted = {};
+ this._changed = {};
+ this._added = {};
+ },
+
+ _setupSaveRequest: function(saveKeywordArgs, requestKw) {
+ /* summary:
+ * This function prepares the save request by populating requestKw,
+ * an associative array that will be passed to dojo.io.bind.
+ */
+ requestKw.url = this._serverSaveUrl;
+ requestKw.method = 'post';
+ requestKw.mimetype = "text/plain";
+ var deleted = [];
+ for (var key in this._deleted) {
+ deleted.push(key);
+ }
+ //don't need _added in saveStruct, changed covers that info
+ var saveStruct = {'changed': this._changed, 'deleted': deleted };
+ var oldRegistry = dojo.json.jsonRegistry;
+ dojo.json.jsonRegistry = this._jsonRegistry;
+ var jsonString = dojo.json.serialize(saveStruct);
+ dojo.json.jsonRegistry = oldRegistry;
+ requestKw.postContent = jsonString;
+ },
+
+ save: function(/* object? */ keywordArgs) {
+ /* summary:
+ * Saves all the changes that have been made.
+ * keywordArgs:
+ * The optional keywordArgs parameter may contain 'sync' to specify
+ * whether the save operation is asynchronous or not. The default is
+ * asynchronous.
+ * examples:
+ * store.save();
+ * store.save({sync:true});
+ * store.save({sync:false});
+ */
+ keywordArgs = keywordArgs || {};
+ var result = new dojo.Deferred();
+ var self = this;
+
+ var bindfunc = function(type, data, evt) {
+ if(type == "load"){
+ if (result.fired == 1) {
+ //it seems that mysteriously "load" sometime
+ //gets called after "error"
+ //so check if an error has already occurred
+ //and stop if it has
+ return;
+ }
+ //update this._data upon save
+ var key = null;
+ for (key in self._added) {
+ if (!self._data[key])
+ self._data[key] = [{} , 1];
+ }
+ for (key in self._changed) {
+ var existing = self._data[key];
+ var changes = self._changed[key];
+ if (existing) {
+ existing[0] = changes;
+ } else {
+ self._data[key] = [changes, 1];
+ }
+ }
+ for (key in self._deleted) {
+ if (self._data[key]) {
+ delete self._data[key];
+ }
+ }
+ self._initChanges();
+ result.callback(true); //todo: what result to pass?
+ } else if(type == "error" || type == 'timeout'){
+ result.errback(data); //todo: how to handle timeout
+ }
+ };
+
+ var bindKw = { sync: keywordArgs["sync"], handle: bindfunc };
+ this._setupSaveRequest(keywordArgs, bindKw);
+ var request = dojo.io.bind(bindKw);
+ result.canceller = function(deferred) { request.abort(); };
+
+ return result;
+ },
+
+ revert: function() {
+ this._initChanges();
+ return true;
+ },
+
+ isDirty: function(/*item?*/ item) {
+ if (item) {
+ // return true if this item is dirty
+ var identity = item.id || item;
+ return this._deleted[identity] || this._changed[identity];
+ } else {
+ // return true if any item is dirty
+ var key = null;
+ for (key in this._changed) {
+ return true;
+ }
+ for (key in this._deleted) {
+ return true;
+ }
+ for (key in this._added) {
+ return true;
+ }
+
+ return false;
+ }
+ },
+
+/**
+additional public methods
+*/
+ createReference: function(idstring) {
+ return { id : idstring };
+ },
+
+ getSize: function() {
+ return this._numItems;
+ },
+
+ forgetResults: function(query) {
+ var queryKey = this._queryToQueryKey(query);
+ var results = this._results[queryKey];
+ if (!results) return false;
+
+ var removed = 0;
+ for (var i = 0; i < results.length; i++) {
+ var key = results[i];
+ var existingValue = this._data[key];
+ if (existingValue[1] <= 1) {
+ delete this._data[key];
+ removed++;
+ }
+ else
+ existingValue[1] = --existingValue[1];
+ }
+ delete this._results[queryKey];
+ this._numItems -= removed;
+ return true;
+ }
+});
+
+
+
diff --git a/source/web/scripts/ajax/dojo/src/data/core/Result.js b/source/web/scripts/ajax/dojo/src/data/core/Result.js
new file mode 100644
index 0000000000..da6a4e63d9
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/core/Result.js
@@ -0,0 +1,58 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.core.Result");
+dojo.require("dojo.lang.declare");
+dojo.require("dojo.experimental");
+
+/* summary:
+ * Instances of dojo.data.core.Result are returned by the find() method
+ * of datastores that implement the dojo.data.core.Read API. For more
+ * documentation, see the find() method on dojo.data.core.Read.
+ */
+dojo.experimental("dojo.data.core.Result");
+
+dojo.declare("dojo.data.core.Result", null, {
+ initializer: function(/* object */ keywordArgs, /* dojo.data.core.Read */ store) {
+ this.fromKwArgs(keywordArgs || {});
+ this.items = null;
+ this.resultMetadata = null;
+ this.length = -1; // -1 until completion
+ this.store = store;
+
+ this._aborted = false;
+ this._abortFunc = null;
+ },
+
+ /* Whether the request should be made synchronously.
+ * We default to true if there's no {sync:false} property in the keywordArgs
+ * in the initializer for a given instance of dojo.data.core.Result.
+ */
+ sync: true,
+
+ //timeout: function(type){ }, todo: support this
+ //timeoutSeconds: 0, todo: support this
+
+ // the abort method needs to be filled in by the transport that accepts the
+ // bind() request
+ abort: function() {
+ this._aborted = true;
+ if (this._abortFunc) {
+ this._abortFunc();
+ }
+ },
+
+ fromKwArgs: function(/* object */ kwArgs) {
+ if (typeof kwArgs.saveResult == "undefined") {
+ this.saveResult = kwArgs.onnext ? false : true;
+ }
+ dojo.lang.mixin(this, kwArgs);
+ }
+});
diff --git a/source/web/scripts/ajax/dojo/src/data/core/Write.js b/source/web/scripts/ajax/dojo/src/data/core/Write.js
new file mode 100644
index 0000000000..24df296a2e
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/core/Write.js
@@ -0,0 +1,169 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.core.Write");
+dojo.require("dojo.data.core.Read");
+dojo.require("dojo.lang.declare");
+dojo.require("dojo.experimental");
+
+/* summary:
+ * This is an abstract API that data provider implementations conform to.
+ * This file defines methods signatures and intentionally leaves all the
+ * methods unimplemented.
+ */
+dojo.experimental("dojo.data.core.Write");
+
+dojo.declare("dojo.data.core.Write", dojo.data.core.Read, {
+ newItem: function(/* object? */ keywordArgs) {
+ /* summary:
+ * Returns a newly created item. Sets the attributes of the new
+ * item based on the *keywordArgs* provided.
+ */
+
+ /* exceptions:
+ * Throws an exception if *keywordArgs* is a string or a number or
+ * anything other than a simple anonymous object.
+ * examples:
+ * var kermit = store.newItem({name: "Kermit", color:[blue, green]});
+ */
+ var newItem;
+ dojo.unimplemented('dojo.data.core.Write.newItem');
+ return newItem; // item
+ },
+
+ deleteItem: function(/* item */ item) {
+ /* summary:
+ * Deletes an item from the store.
+ */
+
+ /* exceptions:
+ * Throws an exception if the argument *item* is not an item
+ * (if store.isItem(item) returns false).
+ * examples:
+ * var success = store.deleteItem(kermit);
+ */
+ dojo.unimplemented('dojo.data.core.Write.deleteItem');
+ return false; // boolean
+ },
+
+ set: function(/* item */ item, /* attribute || string */ attribute, /* almost anything */ value) {
+ /* summary:
+ * Sets the value of an attribute on an item.
+ * Replaces any previous value or values.
+ */
+
+ /* exceptions:
+ * Throws an exception if *item* is not an item, or if *attribute*
+ * is neither an attribute object or a string.
+ * Throws an exception if *value* is undefined.
+ * examples:
+ * var success = store.set(kermit, "color", "green");
+ */
+ dojo.unimplemented('dojo.data.core.Write.set');
+ return false; // boolean
+ },
+
+ setValues: function(/* item */ item, /* attribute || string */ attribute, /* array */ values) {
+ /* summary:
+ * Adds each value in the *values* array as a value of the given
+ * attribute on the given item.
+ * Replaces any previous value or values.
+ * Calling store.setValues(x, y, []) (with *values* as an empty array) has
+ * the same effect as calling store.clear(x, y).
+ */
+
+ /* exceptions:
+ * Throws an exception if *values* is not an array, if *item* is not an
+ * item, or if *attribute* is neither an attribute object or a string.
+ * examples:
+ * var success = store.setValues(kermit, "color", ["green", "aqua"]);
+ * success = store.setValues(kermit, "color", []);
+ * if (success) {assert(!store.hasAttribute(kermit, "color"));}
+ */
+ dojo.unimplemented('dojo.data.core.Write.setValues');
+ return false; // boolean
+ },
+
+ unsetAttribute: function(/* item */ item, /* attribute || string */ attribute) {
+ /* summary:
+ * Deletes all the values of an attribute on an item.
+ */
+
+ /* exceptions:
+ * Throws an exception if *item* is not an item, or if *attribute*
+ * is neither an attribute object or a string.
+ * examples:
+ * var success = store.unsetAttribute(kermit, "color");
+ * if (success) {assert(!store.hasAttribute(kermit, "color"));}
+ */
+ dojo.unimplemented('dojo.data.core.Write.clear');
+ return false; // boolean
+ },
+
+ save: function() {
+ /* summary:
+ * Saves to the server all the changes that have been made locally.
+ * The save operation may take some time. By default the save will
+ * be done synchronously, before the call returns. The caller may
+ * be request an asynchronous save by passing {async: true}.
+ * If the caller requests an asynchronous save, the data store may do
+ * either a synchronous or asynchronous save, whichever it prefers.
+ * Different data store implementations may take additional optional
+ * parameters.
+ * description:
+ * ISSUE -
+ * Should the async save take a callback, like this:
+ * store.save({sync: false, onComplete: callback});
+ * Or should the async save return a Deferred, like this:
+ * var deferred = store.save({sync: false});
+ * deferred.addCallbacks(successCallback, errorCallback);
+ * Or should save() return boolean, like this:
+ * var success = store.save();
+ */
+
+ /* examples:
+ * var success = store.save();
+ * var success = store.save({sync: false});
+ */
+ dojo.unimplemented('dojo.data.core.Write.save');
+ return false; // boolean
+ },
+
+ revert: function() {
+ /* summary:
+ * Discards any unsaved changes.
+ */
+
+ /* examples:
+ * var success = store.revert();
+ */
+ dojo.unimplemented('dojo.data.core.Write.revert');
+ return false; // boolean
+ },
+
+ isDirty: function(/* item? */ item) {
+ /* summary:
+ * Given an item, isDirty() returns true if the item has been modified
+ * since the last save(). If isDirty() is called with no *item* argument,
+ * then this method returns true if any item has been modified since
+ * the last save().
+ */
+
+ /* exceptions:
+ * Throws an exception if isDirty() is passed an argument and the
+ * argument is not an item.
+ * examples:
+ * var trueOrFalse = store.isDirty(kermit); // true if kermit is dirty
+ * var trueOrFalse = store.isDirty(); // true if any item is dirty
+ */
+ dojo.unimplemented('dojo.data.core.Write.isDirty');
+ return false; // boolean
+ }
+});
diff --git a/source/web/scripts/ajax/dojo/src/data/old/Attribute.js b/source/web/scripts/ajax/dojo/src/data/old/Attribute.js
new file mode 100644
index 0000000000..3c0a4ceb10
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/Attribute.js
@@ -0,0 +1,62 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.Attribute");
+dojo.require("dojo.data.old.Item");
+dojo.require("dojo.lang.assert");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.Attribute = function(/* dojo.data.old.provider.Base */ dataProvider, /* string */ attributeId) {
+ /**
+ * summary:
+ * An Attribute object represents something like a column in
+ * a relational database.
+ */
+ dojo.lang.assertType(dataProvider, dojo.data.old.provider.Base, {optional: true});
+ dojo.lang.assertType(attributeId, String);
+ dojo.data.old.Item.call(this, dataProvider);
+ this._attributeId = attributeId;
+};
+dojo.inherits(dojo.data.old.Attribute, dojo.data.old.Item);
+
+// -------------------------------------------------------------------
+// Public instance methods
+// -------------------------------------------------------------------
+dojo.data.old.Attribute.prototype.toString = function() {
+ return this._attributeId; // string
+};
+
+dojo.data.old.Attribute.prototype.getAttributeId = function() {
+ /**
+ * summary:
+ * Returns the string token that uniquely identifies this
+ * attribute within the context of a data provider.
+ * For a data provider that accesses relational databases,
+ * typical attributeIds might be tokens like "name", "age",
+ * "ssn", or "dept_key".
+ */
+ return this._attributeId; // string
+};
+
+dojo.data.old.Attribute.prototype.getType = function() {
+ /**
+ * summary: Returns the data type of the values of this attribute.
+ */
+ return this.get('type'); // dojo.data.old.Type or null
+};
+
+dojo.data.old.Attribute.prototype.setType = function(/* dojo.data.old.Type or null */ type) {
+ /**
+ * summary: Sets the data type for this attribute.
+ */
+ this.set('type', type);
+};
diff --git a/source/web/scripts/ajax/dojo/src/data/old/Item.js b/source/web/scripts/ajax/dojo/src/data/old/Item.js
new file mode 100644
index 0000000000..0a2df32a0a
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/Item.js
@@ -0,0 +1,327 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.Item");
+dojo.require("dojo.data.old.Observable");
+dojo.require("dojo.data.old.Value");
+dojo.require("dojo.lang.common");
+dojo.require("dojo.lang.assert");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.Item = function(/* dojo.data.old.provider.Base */ dataProvider) {
+ /**
+ * summary:
+ * An Item has attributes and attribute values, sort of like
+ * a record in a database, or a 'struct' in C. Instances of
+ * the Item class know how to store and retrieve their
+ * attribute values.
+ */
+ dojo.lang.assertType(dataProvider, dojo.data.old.provider.Base, {optional: true});
+ dojo.data.old.Observable.call(this);
+ this._dataProvider = dataProvider;
+ this._dictionaryOfAttributeValues = {};
+};
+dojo.inherits(dojo.data.old.Item, dojo.data.old.Observable);
+
+// -------------------------------------------------------------------
+// Public class methods
+// -------------------------------------------------------------------
+dojo.data.old.Item.compare = function(/* dojo.data.old.Item */ itemOne, /* dojo.data.old.Item */ itemTwo) {
+ /**
+ * summary:
+ * Given two Items to compare, this method returns 0, 1, or -1.
+ * This method is designed to be used by sorting routines, like
+ * the JavaScript built-in Array sort() method.
+ *
+ * Example:
+ *
+ * var a = dataProvider.newItem("kermit");
+ * var b = dataProvider.newItem("elmo");
+ * var c = dataProvider.newItem("grover");
+ * var array = new Array(a, b, c);
+ * array.sort(dojo.data.old.Item.compare);
+ *
+ */
+ dojo.lang.assertType(itemOne, dojo.data.old.Item);
+ if (!dojo.lang.isOfType(itemTwo, dojo.data.old.Item)) {
+ return -1;
+ }
+ var nameOne = itemOne.getName();
+ var nameTwo = itemTwo.getName();
+ if (nameOne == nameTwo) {
+ var attributeArrayOne = itemOne.getAttributes();
+ var attributeArrayTwo = itemTwo.getAttributes();
+ if (attributeArrayOne.length != attributeArrayTwo.length) {
+ if (attributeArrayOne.length > attributeArrayTwo.length) {
+ return 1;
+ } else {
+ return -1;
+ }
+ }
+ for (var i in attributeArrayOne) {
+ var attribute = attributeArrayOne[i];
+ var arrayOfValuesOne = itemOne.getValues(attribute);
+ var arrayOfValuesTwo = itemTwo.getValues(attribute);
+ dojo.lang.assert(arrayOfValuesOne && (arrayOfValuesOne.length > 0));
+ if (!arrayOfValuesTwo) {
+ return 1;
+ }
+ if (arrayOfValuesOne.length != arrayOfValuesTwo.length) {
+ if (arrayOfValuesOne.length > arrayOfValuesTwo.length) {
+ return 1;
+ } else {
+ return -1;
+ }
+ }
+ for (var j in arrayOfValuesOne) {
+ var value = arrayOfValuesOne[j];
+ if (!itemTwo.hasAttributeValue(value)) {
+ return 1;
+ }
+ }
+ return 0;
+ }
+ } else {
+ if (nameOne > nameTwo) {
+ return 1;
+ } else {
+ return -1; // 0, 1, or -1
+ }
+ }
+};
+
+// -------------------------------------------------------------------
+// Public instance methods
+// -------------------------------------------------------------------
+dojo.data.old.Item.prototype.toString = function() {
+ /**
+ * Returns a simple string representation of the item.
+ */
+ var arrayOfStrings = [];
+ var attributes = this.getAttributes();
+ for (var i in attributes) {
+ var attribute = attributes[i];
+ var arrayOfValues = this.getValues(attribute);
+ var valueString;
+ if (arrayOfValues.length == 1) {
+ valueString = arrayOfValues[0];
+ } else {
+ valueString = '[';
+ valueString += arrayOfValues.join(', ');
+ valueString += ']';
+ }
+ arrayOfStrings.push(' ' + attribute + ': ' + valueString);
+ }
+ var returnString = '{ ';
+ returnString += arrayOfStrings.join(',\n');
+ returnString += ' }';
+ return returnString; // string
+};
+
+dojo.data.old.Item.prototype.compare = function(/* dojo.data.old.Item */ otherItem) {
+ /**
+ * summary: Compares this Item to another Item, and returns 0, 1, or -1.
+ */
+ return dojo.data.old.Item.compare(this, otherItem); // 0, 1, or -1
+};
+
+dojo.data.old.Item.prototype.isEqual = function(/* dojo.data.old.Item */ otherItem) {
+ /**
+ * summary: Returns true if this Item is equal to the otherItem, or false otherwise.
+ */
+ return (this.compare(otherItem) == 0); // boolean
+};
+
+dojo.data.old.Item.prototype.getName = function() {
+ return this.get('name');
+};
+
+dojo.data.old.Item.prototype.get = function(/* string or dojo.data.old.Attribute */ attributeId) {
+ /**
+ * summary: Returns a single literal value, like "foo" or 33.
+ */
+ // dojo.lang.assertType(attributeId, [String, dojo.data.old.Attribute]);
+ var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId];
+ if (dojo.lang.isUndefined(literalOrValueOrArray)) {
+ return null; // null
+ }
+ if (literalOrValueOrArray instanceof dojo.data.old.Value) {
+ return literalOrValueOrArray.getValue(); // literal
+ }
+ if (dojo.lang.isArray(literalOrValueOrArray)) {
+ var dojoDataValue = literalOrValueOrArray[0];
+ return dojoDataValue.getValue(); // literal
+ }
+ return literalOrValueOrArray; // literal
+};
+
+dojo.data.old.Item.prototype.getValue = function(/* string or dojo.data.old.Attribute */ attributeId) {
+ /**
+ * summary: Returns a single instance of dojo.data.old.Value.
+ */
+ // dojo.lang.assertType(attributeId, [String, dojo.data.old.Attribute]);
+ var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId];
+ if (dojo.lang.isUndefined(literalOrValueOrArray)) {
+ return null; // null
+ }
+ if (literalOrValueOrArray instanceof dojo.data.old.Value) {
+ return literalOrValueOrArray; // dojo.data.old.Value
+ }
+ if (dojo.lang.isArray(literalOrValueOrArray)) {
+ var dojoDataValue = literalOrValueOrArray[0];
+ return dojoDataValue; // dojo.data.old.Value
+ }
+ var literal = literalOrValueOrArray;
+ dojoDataValue = new dojo.data.old.Value(literal);
+ this._dictionaryOfAttributeValues[attributeId] = dojoDataValue;
+ return dojoDataValue; // dojo.data.old.Value
+};
+
+dojo.data.old.Item.prototype.getValues = function(/* string or dojo.data.old.Attribute */ attributeId) {
+ /**
+ * summary: Returns an array of dojo.data.old.Value objects.
+ */
+ // dojo.lang.assertType(attributeId, [String, dojo.data.old.Attribute]);
+ var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId];
+ if (dojo.lang.isUndefined(literalOrValueOrArray)) {
+ return null; // null
+ }
+ if (literalOrValueOrArray instanceof dojo.data.old.Value) {
+ var array = [literalOrValueOrArray];
+ this._dictionaryOfAttributeValues[attributeId] = array;
+ return array; // Array
+ }
+ if (dojo.lang.isArray(literalOrValueOrArray)) {
+ return literalOrValueOrArray; // Array
+ }
+ var literal = literalOrValueOrArray;
+ var dojoDataValue = new dojo.data.old.Value(literal);
+ array = [dojoDataValue];
+ this._dictionaryOfAttributeValues[attributeId] = array;
+ return array; // Array
+};
+
+dojo.data.old.Item.prototype.load = function(/* string or dojo.data.old.Attribute */ attributeId, /* anything */ value) {
+ /**
+ * summary:
+ * Used for loading an attribute value into an item when
+ * the item is first being loaded into memory from some
+ * data store (such as a file).
+ */
+ // dojo.lang.assertType(attributeId, [String, dojo.data.old.Attribute]);
+ this._dataProvider.registerAttribute(attributeId);
+ var literalOrValueOrArray = this._dictionaryOfAttributeValues[attributeId];
+ if (dojo.lang.isUndefined(literalOrValueOrArray)) {
+ this._dictionaryOfAttributeValues[attributeId] = value;
+ return;
+ }
+ if (!(value instanceof dojo.data.old.Value)) {
+ value = new dojo.data.old.Value(value);
+ }
+ if (literalOrValueOrArray instanceof dojo.data.old.Value) {
+ var array = [literalOrValueOrArray, value];
+ this._dictionaryOfAttributeValues[attributeId] = array;
+ return;
+ }
+ if (dojo.lang.isArray(literalOrValueOrArray)) {
+ literalOrValueOrArray.push(value);
+ return;
+ }
+ var literal = literalOrValueOrArray;
+ var dojoDataValue = new dojo.data.old.Value(literal);
+ array = [dojoDataValue, value];
+ this._dictionaryOfAttributeValues[attributeId] = array;
+};
+
+dojo.data.old.Item.prototype.set = function(/* string or dojo.data.old.Attribute */ attributeId, /* anything */ value) {
+ /**
+ * summary:
+ * Used for setting an attribute value as a result of a
+ * user action.
+ */
+ // dojo.lang.assertType(attributeId, [String, dojo.data.old.Attribute]);
+ this._dataProvider.registerAttribute(attributeId);
+ this._dictionaryOfAttributeValues[attributeId] = value;
+ this._dataProvider.noteChange(this, attributeId, value);
+};
+
+dojo.data.old.Item.prototype.setValue = function(/* string or dojo.data.old.Attribute */ attributeId, /* dojo.data.old.Value */ value) {
+ this.set(attributeId, value);
+};
+
+dojo.data.old.Item.prototype.addValue = function(/* string or dojo.data.old.Attribute */ attributeId, /* anything */ value) {
+ /**
+ * summary:
+ * Used for adding an attribute value as a result of a
+ * user action.
+ */
+ this.load(attributeId, value);
+ this._dataProvider.noteChange(this, attributeId, value);
+};
+
+dojo.data.old.Item.prototype.setValues = function(/* string or dojo.data.old.Attribute */ attributeId, /* Array */ arrayOfValues) {
+ /**
+ * summary:
+ * Used for setting an array of attribute values as a result of a
+ * user action.
+ */
+ // dojo.lang.assertType(attributeId, [String, dojo.data.old.Attribute]);
+ dojo.lang.assertType(arrayOfValues, Array);
+ this._dataProvider.registerAttribute(attributeId);
+ var finalArray = [];
+ this._dictionaryOfAttributeValues[attributeId] = finalArray;
+ for (var i in arrayOfValues) {
+ var value = arrayOfValues[i];
+ if (!(value instanceof dojo.data.old.Value)) {
+ value = new dojo.data.old.Value(value);
+ }
+ finalArray.push(value);
+ this._dataProvider.noteChange(this, attributeId, value);
+ }
+};
+
+dojo.data.old.Item.prototype.getAttributes = function() {
+ /**
+ * summary:
+ * Returns an array containing all of the attributes for which
+ * this item has attribute values.
+ */
+ var arrayOfAttributes = [];
+ for (var key in this._dictionaryOfAttributeValues) {
+ arrayOfAttributes.push(this._dataProvider.getAttribute(key));
+ }
+ return arrayOfAttributes; // Array
+};
+
+dojo.data.old.Item.prototype.hasAttribute = function(/* string or dojo.data.old.Attribute */ attributeId) {
+ /**
+ * summary: Returns true if the given attribute of the item has been assigned any value.
+ */
+ // dojo.lang.assertType(attributeId, [String, dojo.data.old.Attribute]);
+ return (attributeId in this._dictionaryOfAttributeValues); // boolean
+};
+
+dojo.data.old.Item.prototype.hasAttributeValue = function(/* string or dojo.data.old.Attribute */ attributeId, /* anything */ value) {
+ /**
+ * summary: Returns true if the given attribute of the item has been assigned the given value.
+ */
+ var arrayOfValues = this.getValues(attributeId);
+ for (var i in arrayOfValues) {
+ var candidateValue = arrayOfValues[i];
+ if (candidateValue.isEqual(value)) {
+ return true; // boolean
+ }
+ }
+ return false; // boolean
+};
+
+
diff --git a/source/web/scripts/ajax/dojo/src/data/old/Kind.js b/source/web/scripts/ajax/dojo/src/data/old/Kind.js
new file mode 100644
index 0000000000..d0d33395df
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/Kind.js
@@ -0,0 +1,28 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.Kind");
+dojo.require("dojo.data.old.Item");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.Kind = function(/* dojo.data.old.provider.Base */ dataProvider) {
+ /**
+ * summary:
+ * A Kind represents a kind of item. In the dojo data model
+ * the item Snoopy might belong to the 'kind' Dog, where in
+ * a Java program the object Snoopy would belong to the 'class'
+ * Dog, and in MySQL the record for Snoopy would be in the
+ * table Dog.
+ */
+ dojo.data.old.Item.call(this, dataProvider);
+};
+dojo.inherits(dojo.data.old.Kind, dojo.data.old.Item);
diff --git a/source/web/scripts/ajax/dojo/src/data/old/Observable.js b/source/web/scripts/ajax/dojo/src/data/old/Observable.js
new file mode 100644
index 0000000000..92ed9730f5
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/Observable.js
@@ -0,0 +1,59 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.Observable");
+dojo.require("dojo.lang.common");
+dojo.require("dojo.lang.assert");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.Observable = function() {
+};
+
+// -------------------------------------------------------------------
+// Public instance methods
+// -------------------------------------------------------------------
+dojo.data.old.Observable.prototype.addObserver = function(/* object */ observer) {
+ /**
+ * summary: Registers an object as an observer of this item,
+ * so that the object will be notified when the item changes.
+ */
+ dojo.lang.assertType(observer, Object);
+ dojo.lang.assertType(observer.observedObjectHasChanged, Function);
+ if (!this._arrayOfObservers) {
+ this._arrayOfObservers = [];
+ }
+ if (!dojo.lang.inArray(this._arrayOfObservers, observer)) {
+ this._arrayOfObservers.push(observer);
+ }
+};
+
+dojo.data.old.Observable.prototype.removeObserver = function(/* object */ observer) {
+ /**
+ * summary: Removes the observer registration for a previously
+ * registered object.
+ */
+ if (!this._arrayOfObservers) {
+ return;
+ }
+ var index = dojo.lang.indexOf(this._arrayOfObservers, observer);
+ if (index != -1) {
+ this._arrayOfObservers.splice(index, 1);
+ }
+};
+
+dojo.data.old.Observable.prototype.getObservers = function() {
+ /**
+ * summary: Returns an array with all the observers of this item.
+ */
+ return this._arrayOfObservers; // Array or undefined
+};
+
diff --git a/source/web/scripts/ajax/dojo/src/data/old/ResultSet.js b/source/web/scripts/ajax/dojo/src/data/old/ResultSet.js
new file mode 100644
index 0000000000..14cee415cd
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/ResultSet.js
@@ -0,0 +1,70 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.ResultSet");
+dojo.require("dojo.lang.assert");
+dojo.require("dojo.collections.Collections");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.ResultSet = function(/* dojo.data.old.provider.Base */ dataProvider, /* Array */ arrayOfItems) {
+ /**
+ * summary:
+ * A ResultSet holds a collection of Items. A data provider
+ * returns a ResultSet in reponse to a query.
+ * (The name "Result Set" comes from the MySQL terminology.)
+ */
+ dojo.lang.assertType(dataProvider, dojo.data.old.provider.Base, {optional: true});
+ dojo.lang.assertType(arrayOfItems, Array, {optional: true});
+ dojo.data.old.Observable.call(this);
+ this._dataProvider = dataProvider;
+ this._arrayOfItems = [];
+ if (arrayOfItems) {
+ this._arrayOfItems = arrayOfItems;
+ }
+};
+dojo.inherits(dojo.data.old.ResultSet, dojo.data.old.Observable);
+
+// -------------------------------------------------------------------
+// Public instance methods
+// -------------------------------------------------------------------
+dojo.data.old.ResultSet.prototype.toString = function() {
+ var returnString = this._arrayOfItems.join(', ');
+ return returnString; // string
+};
+
+dojo.data.old.ResultSet.prototype.toArray = function() {
+ return this._arrayOfItems; // Array
+};
+
+dojo.data.old.ResultSet.prototype.getIterator = function() {
+ return new dojo.collections.Iterator(this._arrayOfItems);
+};
+
+dojo.data.old.ResultSet.prototype.getLength = function() {
+ return this._arrayOfItems.length; // integer
+};
+
+dojo.data.old.ResultSet.prototype.getItemAt = function(/* numeric */ index) {
+ return this._arrayOfItems[index];
+};
+
+dojo.data.old.ResultSet.prototype.indexOf = function(/* dojo.data.old.Item */ item) {
+ return dojo.lang.indexOf(this._arrayOfItems, item); // integer
+};
+
+dojo.data.old.ResultSet.prototype.contains = function(/* dojo.data.old.Item */ item) {
+ return dojo.lang.inArray(this._arrayOfItems, item); // boolean
+};
+
+dojo.data.old.ResultSet.prototype.getDataProvider = function() {
+ return this._dataProvider; // dojo.data.old.provider.Base
+};
\ No newline at end of file
diff --git a/source/web/scripts/ajax/dojo/src/data/old/Type.js b/source/web/scripts/ajax/dojo/src/data/old/Type.js
new file mode 100644
index 0000000000..19f175583c
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/Type.js
@@ -0,0 +1,25 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.Type");
+dojo.require("dojo.data.old.Item");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.Type = function(/* dojo.data.old.provider.Base */ dataProvider) {
+ /**
+ * summary:
+ * A Type represents a type of value, like Text, Number, Picture,
+ * or Varchar.
+ */
+ dojo.data.old.Item.call(this, dataProvider);
+};
+dojo.inherits(dojo.data.old.Type, dojo.data.old.Item);
diff --git a/source/web/scripts/ajax/dojo/src/data/old/Value.js b/source/web/scripts/ajax/dojo/src/data/old/Value.js
new file mode 100644
index 0000000000..7ff1f6fc3c
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/Value.js
@@ -0,0 +1,55 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.Value");
+dojo.require("dojo.lang.assert");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.Value = function(/* anything */ value) {
+ /**
+ * summary:
+ * A Value represents a simple literal value (like "foo" or 334),
+ * or a reference value (a pointer to an Item).
+ */
+ this._value = value;
+ this._type = null;
+};
+
+// -------------------------------------------------------------------
+// Public instance methods
+// -------------------------------------------------------------------
+dojo.data.old.Value.prototype.toString = function() {
+ return this._value.toString(); // string
+};
+
+dojo.data.old.Value.prototype.getValue = function() {
+ /**
+ * summary: Returns the value itself.
+ */
+ return this._value; // anything
+};
+
+dojo.data.old.Value.prototype.getType = function() {
+ /**
+ * summary: Returns the data type of the value.
+ */
+ dojo.unimplemented('dojo.data.old.Value.prototype.getType');
+ return this._type; // dojo.data.old.Type
+};
+
+dojo.data.old.Value.prototype.compare = function() {
+ dojo.unimplemented('dojo.data.old.Value.prototype.compare');
+};
+
+dojo.data.old.Value.prototype.isEqual = function() {
+ dojo.unimplemented('dojo.data.old.Value.prototype.isEqual');
+};
diff --git a/source/web/scripts/ajax/dojo/src/data/old/__package__.js b/source/web/scripts/ajax/dojo/src/data/old/__package__.js
new file mode 100644
index 0000000000..673d3e939b
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/__package__.js
@@ -0,0 +1,22 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.require("dojo.experimental");
+
+dojo.experimental("dojo.data.old.*");
+dojo.kwCompoundRequire({
+ common: [
+ "dojo.data.old.Item",
+ "dojo.data.old.ResultSet",
+ "dojo.data.old.provider.FlatFile"
+ ]
+});
+dojo.provide("dojo.data.old.*");
+
diff --git a/source/web/scripts/ajax/dojo/src/data/old/format/Csv.js b/source/web/scripts/ajax/dojo/src/data/old/format/Csv.js
new file mode 100644
index 0000000000..44cfc78d38
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/format/Csv.js
@@ -0,0 +1,112 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.format.Csv");
+dojo.require("dojo.lang.assert");
+
+
+dojo.data.old.format.Csv = new function() {
+
+ // -------------------------------------------------------------------
+ // Public functions
+ // -------------------------------------------------------------------
+ this.getArrayStructureFromCsvFileContents = function(/* string */ csvFileContents) {
+ /**
+ * Given a string containing CSV records, this method parses
+ * the string and returns a data structure containing the parsed
+ * content. The data structure we return is an array of length
+ * R, where R is the number of rows (lines) in the CSV data. The
+ * return array contains one sub-array for each CSV line, and each
+ * sub-array contains C string values, where C is the number of
+ * columns in the CSV data.
+ *
+ * For example, given this CSV string as input:
+ *
+ * "Title, Year, Producer \n Alien, 1979, Ridley Scott \n Blade Runner, 1982, Ridley Scott"
+ *
+ * We will return this data structure:
+ *
+ * [["Title", "Year", "Producer"]
+ * ["Alien", "1979", "Ridley Scott"],
+ * ["Blade Runner", "1982", "Ridley Scott"]]
+ *
+ */
+ dojo.lang.assertType(csvFileContents, String);
+
+ var lineEndingCharacters = new RegExp("\r\n|\n|\r");
+ var leadingWhiteSpaceCharacters = new RegExp("^\\s+",'g');
+ var trailingWhiteSpaceCharacters = new RegExp("\\s+$",'g');
+ var doubleQuotes = new RegExp('""','g');
+ var arrayOfOutputRecords = [];
+
+ var arrayOfInputLines = csvFileContents.split(lineEndingCharacters);
+ for (var i in arrayOfInputLines) {
+ var singleLine = arrayOfInputLines[i];
+ if (singleLine.length > 0) {
+ var listOfFields = singleLine.split(',');
+ var j = 0;
+ while (j < listOfFields.length) {
+ var space_field_space = listOfFields[j];
+ var field_space = space_field_space.replace(leadingWhiteSpaceCharacters, ''); // trim leading whitespace
+ var field = field_space.replace(trailingWhiteSpaceCharacters, ''); // trim trailing whitespace
+ var firstChar = field.charAt(0);
+ var lastChar = field.charAt(field.length - 1);
+ var secondToLastChar = field.charAt(field.length - 2);
+ var thirdToLastChar = field.charAt(field.length - 3);
+ if ((firstChar == '"') &&
+ ((lastChar != '"') ||
+ ((lastChar == '"') && (secondToLastChar == '"') && (thirdToLastChar != '"')) )) {
+ if (j+1 === listOfFields.length) {
+ // alert("The last field in record " + i + " is corrupted:\n" + field);
+ return null;
+ }
+ var nextField = listOfFields[j+1];
+ listOfFields[j] = field_space + ',' + nextField;
+ listOfFields.splice(j+1, 1); // delete element [j+1] from the list
+ } else {
+ if ((firstChar == '"') && (lastChar == '"')) {
+ field = field.slice(1, (field.length - 1)); // trim the " characters off the ends
+ field = field.replace(doubleQuotes, '"'); // replace "" with "
+ }
+ listOfFields[j] = field;
+ j += 1;
+ }
+ }
+ arrayOfOutputRecords.push(listOfFields);
+ }
+ }
+ return arrayOfOutputRecords; // Array
+ };
+
+ this.loadDataProviderFromFileContents = function(/* dojo.data.old.provider.Base */ dataProvider, /* string */ csvFileContents) {
+ dojo.lang.assertType(dataProvider, dojo.data.old.provider.Base);
+ dojo.lang.assertType(csvFileContents, String);
+ var arrayOfArrays = this.getArrayStructureFromCsvFileContents(csvFileContents);
+ if (arrayOfArrays) {
+ var arrayOfKeys = arrayOfArrays[0];
+ for (var i = 1; i < arrayOfArrays.length; ++i) {
+ var row = arrayOfArrays[i];
+ var item = dataProvider.getNewItemToLoad();
+ for (var j in row) {
+ var value = row[j];
+ var key = arrayOfKeys[j];
+ item.load(key, value);
+ }
+ }
+ }
+ };
+
+ this.getCsvStringFromResultSet = function(/* dojo.data.old.ResultSet */ resultSet) {
+ dojo.unimplemented('dojo.data.old.format.Csv.getCsvStringFromResultSet');
+ var csvString = null;
+ return csvString; // String
+ };
+
+}();
diff --git a/source/web/scripts/ajax/dojo/src/data/old/format/Json.js b/source/web/scripts/ajax/dojo/src/data/old/format/Json.js
new file mode 100644
index 0000000000..50d54eda16
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/format/Json.js
@@ -0,0 +1,103 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.format.Json");
+dojo.require("dojo.lang.assert");
+
+dojo.data.old.format.Json = new function() {
+
+ // -------------------------------------------------------------------
+ // Public functions
+ // -------------------------------------------------------------------
+ this.loadDataProviderFromFileContents = function(/* dojo.data.old.provider.Base */ dataProvider, /* string */ jsonFileContents) {
+ dojo.lang.assertType(dataProvider, dojo.data.old.provider.Base);
+ dojo.lang.assertType(jsonFileContents, String);
+ var arrayOfJsonData = eval("(" + jsonFileContents + ")");
+ this.loadDataProviderFromArrayOfJsonData(dataProvider, arrayOfJsonData);
+ };
+
+ this.loadDataProviderFromArrayOfJsonData = function(/* dojo.data.old.provider.Base */ dataProvider, /* Array */ arrayOfJsonData) {
+ dojo.lang.assertType(arrayOfJsonData, Array, {optional: true});
+ if (arrayOfJsonData && (arrayOfJsonData.length > 0)) {
+ var firstRow = arrayOfJsonData[0];
+ dojo.lang.assertType(firstRow, [Array, "pureobject"]);
+ if (dojo.lang.isArray(firstRow)) {
+ _loadDataProviderFromArrayOfArrays(dataProvider, arrayOfJsonData);
+ } else {
+ dojo.lang.assertType(firstRow, "pureobject");
+ _loadDataProviderFromArrayOfObjects(dataProvider, arrayOfJsonData);
+ }
+ }
+ };
+
+ this.getJsonStringFromResultSet = function(/* dojo.data.old.ResultSet */ resultSet) {
+ dojo.unimplemented('dojo.data.old.format.Json.getJsonStringFromResultSet');
+ var jsonString = null;
+ return jsonString; // String
+ };
+
+ // -------------------------------------------------------------------
+ // Private functions
+ // -------------------------------------------------------------------
+ function _loadDataProviderFromArrayOfArrays(/* dojo.data.old.provider.Base */ dataProvider, /* Array */ arrayOfJsonData) {
+ /**
+ * Example:
+ * var arrayOfJsonStates = [
+ * [ "abbr", "population", "name" ]
+ * [ "WA", 5894121, "Washington" ],
+ * [ "WV", 1808344, "West Virginia" ],
+ * [ "WI", 5453896, "Wisconsin" ],
+ * [ "WY", 493782, "Wyoming" ] ];
+ * this._loadFromArrayOfArrays(arrayOfJsonStates);
+ */
+ var arrayOfKeys = arrayOfJsonData[0];
+ for (var i = 1; i < arrayOfJsonData.length; ++i) {
+ var row = arrayOfJsonData[i];
+ var item = dataProvider.getNewItemToLoad();
+ for (var j in row) {
+ var value = row[j];
+ var key = arrayOfKeys[j];
+ item.load(key, value);
+ }
+ }
+ }
+
+ function _loadDataProviderFromArrayOfObjects(/* dojo.data.old.provider.Base */ dataProvider, /* Array */ arrayOfJsonData) {
+ /**
+ * Example:
+ * var arrayOfJsonStates = [
+ * { abbr: "WA", name: "Washington" },
+ * { abbr: "WV", name: "West Virginia" },
+ * { abbr: "WI", name: "Wisconsin", song: "On, Wisconsin!" },
+ * { abbr: "WY", name: "Wyoming", cities: ["Lander", "Cheyenne", "Laramie"] } ];
+ * this._loadFromArrayOfArrays(arrayOfJsonStates);
+ */
+ // dojo.debug("_loadDataProviderFromArrayOfObjects");
+ for (var i in arrayOfJsonData) {
+ var row = arrayOfJsonData[i];
+ var item = dataProvider.getNewItemToLoad();
+ for (var key in row) {
+ var value = row[key];
+ if (dojo.lang.isArray(value)) {
+ var arrayOfValues = value;
+ for (var j in arrayOfValues) {
+ value = arrayOfValues[j];
+ item.load(key, value);
+ // dojo.debug("loaded: " + key + " = " + value);
+ }
+ } else {
+ item.load(key, value);
+ }
+ }
+ }
+ }
+
+}();
+
diff --git a/source/web/scripts/ajax/dojo/src/data/old/provider/Base.js b/source/web/scripts/ajax/dojo/src/data/old/provider/Base.js
new file mode 100644
index 0000000000..67509b0b5e
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/provider/Base.js
@@ -0,0 +1,183 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.provider.Base");
+dojo.require("dojo.lang.assert");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.provider.Base = function() {
+ /**
+ * summary:
+ * A Data Provider serves as a connection to some data source,
+ * like a relational database. This data provider Base class
+ * serves as an abstract superclass for other data provider
+ * classes.
+ */
+ this._countOfNestedTransactions = 0;
+ this._changesInCurrentTransaction = null;
+};
+
+// -------------------------------------------------------------------
+// Public instance methods
+// -------------------------------------------------------------------
+dojo.data.old.provider.Base.prototype.beginTransaction = function() {
+ /**
+ * Marks the beginning of a transaction.
+ *
+ * Each time you call beginTransaction() you open a new transaction,
+ * which you need to close later using endTransaction(). Transactions
+ * may be nested, but the beginTransaction and endTransaction calls
+ * always need to come in pairs.
+ */
+ if (this._countOfNestedTransactions === 0) {
+ this._changesInCurrentTransaction = [];
+ }
+ this._countOfNestedTransactions += 1;
+};
+
+dojo.data.old.provider.Base.prototype.endTransaction = function() {
+ /**
+ * Marks the end of a transaction.
+ */
+ this._countOfNestedTransactions -= 1;
+ dojo.lang.assert(this._countOfNestedTransactions >= 0);
+
+ if (this._countOfNestedTransactions === 0) {
+ var listOfChangesMade = this._saveChanges();
+ this._changesInCurrentTransaction = null;
+ if (listOfChangesMade.length > 0) {
+ // dojo.debug("endTransaction: " + listOfChangesMade.length + " changes made");
+ this._notifyObserversOfChanges(listOfChangesMade);
+ }
+ }
+};
+
+dojo.data.old.provider.Base.prototype.getNewItemToLoad = function() {
+ return this._newItem(); // dojo.data.old.Item
+};
+
+dojo.data.old.provider.Base.prototype.newItem = function(/* string */ itemName) {
+ /**
+ * Creates a new item.
+ */
+ dojo.lang.assertType(itemName, String, {optional: true});
+ var item = this._newItem();
+ if (itemName) {
+ item.set('name', itemName);
+ }
+ return item; // dojo.data.old.Item
+};
+
+dojo.data.old.provider.Base.prototype.newAttribute = function(/* string */ attributeId) {
+ /**
+ * Creates a new attribute.
+ */
+ dojo.lang.assertType(attributeId, String, {optional: true});
+ var attribute = this._newAttribute(attributeId);
+ return attribute; // dojo.data.old.Attribute
+};
+
+dojo.data.old.provider.Base.prototype.getAttribute = function(/* string */ attributeId) {
+ dojo.unimplemented('dojo.data.old.provider.Base');
+ var attribute;
+ return attribute; // dojo.data.old.Attribute
+};
+
+dojo.data.old.provider.Base.prototype.getAttributes = function() {
+ dojo.unimplemented('dojo.data.old.provider.Base');
+ return this._arrayOfAttributes; // Array
+};
+
+dojo.data.old.provider.Base.prototype.fetchArray = function() {
+ dojo.unimplemented('dojo.data.old.provider.Base');
+ return []; // Array
+};
+
+dojo.data.old.provider.Base.prototype.fetchResultSet = function() {
+ dojo.unimplemented('dojo.data.old.provider.Base');
+ var resultSet;
+ return resultSet; // dojo.data.old.ResultSet
+};
+
+dojo.data.old.provider.Base.prototype.noteChange = function(/* dojo.data.old.Item */ item, /* string or dojo.data.old.Attribute */ attribute, /* anything */ value) {
+ var change = {item: item, attribute: attribute, value: value};
+ if (this._countOfNestedTransactions === 0) {
+ this.beginTransaction();
+ this._changesInCurrentTransaction.push(change);
+ this.endTransaction();
+ } else {
+ this._changesInCurrentTransaction.push(change);
+ }
+};
+
+dojo.data.old.provider.Base.prototype.addItemObserver = function(/* dojo.data.old.Item */ item, /* object */ observer) {
+ /**
+ * summary: Registers an object as an observer of an item,
+ * so that the object will be notified when the item changes.
+ */
+ dojo.lang.assertType(item, dojo.data.old.Item);
+ item.addObserver(observer);
+};
+
+dojo.data.old.provider.Base.prototype.removeItemObserver = function(/* dojo.data.old.Item */ item, /* object */ observer) {
+ /**
+ * summary: Removes the observer registration for a previously
+ * registered object.
+ */
+ dojo.lang.assertType(item, dojo.data.old.Item);
+ item.removeObserver(observer);
+};
+
+// -------------------------------------------------------------------
+// Private instance methods
+// -------------------------------------------------------------------
+dojo.data.old.provider.Base.prototype._newItem = function() {
+ var item = new dojo.data.old.Item(this);
+ return item; // dojo.data.old.Item
+};
+
+dojo.data.old.provider.Base.prototype._newAttribute = function(/* String */ attributeId) {
+ var attribute = new dojo.data.old.Attribute(this);
+ return attribute; // dojo.data.old.Attribute
+};
+
+dojo.data.old.provider.Base.prototype._saveChanges = function() {
+ var arrayOfChangesMade = this._changesInCurrentTransaction;
+ return arrayOfChangesMade; // Array
+};
+
+dojo.data.old.provider.Base.prototype._notifyObserversOfChanges = function(/* Array */ arrayOfChanges) {
+ var arrayOfResultSets = this._getResultSets();
+ for (var i in arrayOfChanges) {
+ var change = arrayOfChanges[i];
+ var changedItem = change.item;
+ var arrayOfItemObservers = changedItem.getObservers();
+ for (var j in arrayOfItemObservers) {
+ var observer = arrayOfItemObservers[j];
+ observer.observedObjectHasChanged(changedItem, change);
+ }
+ for (var k in arrayOfResultSets) {
+ var resultSet = arrayOfResultSets[k];
+ var arrayOfResultSetObservers = resultSet.getObservers();
+ for (var m in arrayOfResultSetObservers) {
+ observer = arrayOfResultSetObservers[m];
+ observer.observedObjectHasChanged(resultSet, change);
+ }
+ }
+ }
+};
+
+dojo.data.old.provider.Base.prototype._getResultSets = function() {
+ dojo.unimplemented('dojo.data.old.provider.Base');
+ return []; // Array
+};
+
diff --git a/source/web/scripts/ajax/dojo/src/data/old/provider/Delicious.js b/source/web/scripts/ajax/dojo/src/data/old/provider/Delicious.js
new file mode 100644
index 0000000000..d5f354b9c9
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/provider/Delicious.js
@@ -0,0 +1,85 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.provider.Delicious");
+dojo.require("dojo.data.old.provider.FlatFile");
+dojo.require("dojo.data.old.format.Json");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.provider.Delicious = function() {
+ /**
+ * summary:
+ * The Delicious Data Provider can be used to take data from
+ * del.icio.us and make it available as dojo.data.old.Items
+ * In order to use the Delicious Data Provider, you need
+ * to have loaded a script tag that looks like this:
+ *
+ */
+ dojo.data.old.provider.FlatFile.call(this);
+ // Delicious = null;
+ if (Delicious && Delicious.posts) {
+ dojo.data.old.format.Json.loadDataProviderFromArrayOfJsonData(this, Delicious.posts);
+ } else {
+ // document.write("");
+ /*
+ document.write("");
+ document.write("");
+ document.write("");
+ fetchComplete();
+ */
+ // dojo.debug("Delicious line 29: constructor");
+ }
+ var u = this.registerAttribute('u');
+ var d = this.registerAttribute('d');
+ var t = this.registerAttribute('t');
+
+ u.load('name', 'Bookmark');
+ d.load('name', 'Description');
+ t.load('name', 'Tags');
+
+ u.load('type', 'String');
+ d.load('type', 'String');
+ t.load('type', 'String');
+};
+dojo.inherits(dojo.data.old.provider.Delicious, dojo.data.old.provider.FlatFile);
+
+/********************************************************************
+ * FIXME: the rest of this is work in progress
+ *
+
+dojo.data.old.provider.Delicious.prototype.getNewItemToLoad = function() {
+ var newItem = this._newItem();
+ this._currentArray.push(newItem);
+ return newItem; // dojo.data.old.Item
+};
+
+dojo.data.old.provider.Delicious.prototype.fetchArray = function(query) {
+ if (!query) {
+ query = "gumption";
+ }
+ this._currentArray = [];
+ alert("Delicious line 60: loadDataProviderFromArrayOfJsonData");
+ alert("Delicious line 61: " + dojo);
+ var sourceUrl = "http://del.icio.us/feeds/json/" + query + "?count=8";
+ document.write("");
+ document.write("");
+ document.write("");
+ alert("line 66");
+ dojo.data.old.format.Json.loadDataProviderFromArrayOfJsonData(this, Delicious.posts);
+ return this._currentArray; // Array
+};
+
+callMe = function() {
+ alert("callMe!");
+};
+
+*/
diff --git a/source/web/scripts/ajax/dojo/src/data/old/provider/FlatFile.js b/source/web/scripts/ajax/dojo/src/data/old/provider/FlatFile.js
new file mode 100644
index 0000000000..fa95a11a18
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/provider/FlatFile.js
@@ -0,0 +1,153 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.provider.FlatFile");
+dojo.require("dojo.data.old.provider.Base");
+dojo.require("dojo.data.old.Item");
+dojo.require("dojo.data.old.Attribute");
+dojo.require("dojo.data.old.ResultSet");
+dojo.require("dojo.data.old.format.Json");
+dojo.require("dojo.data.old.format.Csv");
+dojo.require("dojo.lang.assert");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.provider.FlatFile = function(/* keywords */ keywordParameters) {
+ /**
+ * summary:
+ * A Json Data Provider knows how to read in simple JSON data
+ * tables and make their contents accessable as Items.
+ */
+ dojo.lang.assertType(keywordParameters, "pureobject", {optional: true});
+ dojo.data.old.provider.Base.call(this);
+ this._arrayOfItems = [];
+ this._resultSet = null;
+ this._dictionaryOfAttributes = {};
+
+ if (keywordParameters) {
+ var jsonObjects = keywordParameters["jsonObjects"];
+ var jsonString = keywordParameters["jsonString"];
+ var fileUrl = keywordParameters["url"];
+ if (jsonObjects) {
+ dojo.data.old.format.Json.loadDataProviderFromArrayOfJsonData(this, jsonObjects);
+ }
+ if (jsonString) {
+ dojo.data.old.format.Json.loadDataProviderFromFileContents(this, jsonString);
+ }
+ if (fileUrl) {
+ var arrayOfParts = fileUrl.split('.');
+ var lastPart = arrayOfParts[(arrayOfParts.length - 1)];
+ var formatParser = null;
+ if (lastPart == "json") {
+ formatParser = dojo.data.old.format.Json;
+ }
+ if (lastPart == "csv") {
+ formatParser = dojo.data.old.format.Csv;
+ }
+ if (formatParser) {
+ var fileContents = dojo.hostenv.getText(fileUrl);
+ formatParser.loadDataProviderFromFileContents(this, fileContents);
+ } else {
+ dojo.lang.assert(false, "new dojo.data.old.provider.FlatFile({url: }) was passed a file without a .csv or .json suffix");
+ }
+ }
+ }
+};
+dojo.inherits(dojo.data.old.provider.FlatFile, dojo.data.old.provider.Base);
+
+// -------------------------------------------------------------------
+// Public instance methods
+// -------------------------------------------------------------------
+dojo.data.old.provider.FlatFile.prototype.getProviderCapabilities = function(/* string */ keyword) {
+ dojo.lang.assertType(keyword, String, {optional: true});
+ if (!this._ourCapabilities) {
+ this._ourCapabilities = {
+ transactions: false,
+ undo: false,
+ login: false,
+ versioning: false,
+ anonymousRead: true,
+ anonymousWrite: false,
+ permissions: false,
+ queries: false,
+ strongTyping: false,
+ datatypes: [String, Date, Number]
+ };
+ }
+ if (keyword) {
+ return this._ourCapabilities[keyword];
+ } else {
+ return this._ourCapabilities;
+ }
+};
+
+dojo.data.old.provider.FlatFile.prototype.registerAttribute = function(/* string or dojo.data.old.Attribute */ attributeId) {
+ var registeredAttribute = this.getAttribute(attributeId);
+ if (!registeredAttribute) {
+ var newAttribute = new dojo.data.old.Attribute(this, attributeId);
+ this._dictionaryOfAttributes[attributeId] = newAttribute;
+ registeredAttribute = newAttribute;
+ }
+ return registeredAttribute; // dojo.data.old.Attribute
+};
+
+dojo.data.old.provider.FlatFile.prototype.getAttribute = function(/* string or dojo.data.old.Attribute */ attributeId) {
+ var attribute = (this._dictionaryOfAttributes[attributeId] || null);
+ return attribute; // dojo.data.old.Attribute or null
+};
+
+dojo.data.old.provider.FlatFile.prototype.getAttributes = function() {
+ var arrayOfAttributes = [];
+ for (var key in this._dictionaryOfAttributes) {
+ var attribute = this._dictionaryOfAttributes[key];
+ arrayOfAttributes.push(attribute);
+ }
+ return arrayOfAttributes; // Array
+};
+
+dojo.data.old.provider.FlatFile.prototype.fetchArray = function(query) {
+ /**
+ * summary: Returns an Array containing all of the Items.
+ */
+ return this._arrayOfItems; // Array
+};
+
+dojo.data.old.provider.FlatFile.prototype.fetchResultSet = function(query) {
+ /**
+ * summary: Returns a ResultSet containing all of the Items.
+ */
+ if (!this._resultSet) {
+ this._resultSet = new dojo.data.old.ResultSet(this, this.fetchArray(query));
+ }
+ return this._resultSet; // dojo.data.old.ResultSet
+};
+
+// -------------------------------------------------------------------
+// Private instance methods
+// -------------------------------------------------------------------
+dojo.data.old.provider.FlatFile.prototype._newItem = function() {
+ var item = new dojo.data.old.Item(this);
+ this._arrayOfItems.push(item);
+ return item; // dojo.data.old.Item
+};
+
+dojo.data.old.provider.FlatFile.prototype._newAttribute = function(/* String */ attributeId) {
+ dojo.lang.assertType(attributeId, String);
+ dojo.lang.assert(this.getAttribute(attributeId) === null);
+ var attribute = new dojo.data.old.Attribute(this, attributeId);
+ this._dictionaryOfAttributes[attributeId] = attribute;
+ return attribute; // dojo.data.old.Attribute
+};
+
+dojo.data.old.provider.Base.prototype._getResultSets = function() {
+ return [this._resultSet]; // Array
+};
+
diff --git a/source/web/scripts/ajax/dojo/src/data/old/provider/JotSpot.js b/source/web/scripts/ajax/dojo/src/data/old/provider/JotSpot.js
new file mode 100644
index 0000000000..47b326b2e9
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/provider/JotSpot.js
@@ -0,0 +1,27 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.provider.JotSpot");
+dojo.require("dojo.data.old.provider.Base");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.provider.JotSpot = function() {
+ /**
+ * summary:
+ * A JotSpot Data Provider knows how to read data from a JotSpot data
+ * store and make the contents accessable as dojo.data.old.Items.
+ */
+ dojo.unimplemented('dojo.data.old.provider.JotSpot');
+};
+
+dojo.inherits(dojo.data.old.provider.JotSpot, dojo.data.old.provider.Base);
+
diff --git a/source/web/scripts/ajax/dojo/src/data/old/provider/MySql.js b/source/web/scripts/ajax/dojo/src/data/old/provider/MySql.js
new file mode 100644
index 0000000000..bbf443c2fe
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/provider/MySql.js
@@ -0,0 +1,27 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.data.old.provider.MySql");
+dojo.require("dojo.data.old.provider.Base");
+
+// -------------------------------------------------------------------
+// Constructor
+// -------------------------------------------------------------------
+dojo.data.old.provider.MySql = function() {
+ /**
+ * summary:
+ * A MySql Data Provider knows how to connect to a MySQL database
+ * on a server and and make the content records available as
+ * dojo.data.old.Items.
+ */
+ dojo.unimplemented('dojo.data.old.provider.MySql');
+};
+
+dojo.inherits(dojo.data.old.provider.MySql, dojo.data.old.provider.Base);
diff --git a/source/web/scripts/ajax/dojo/src/data/old/to_do.txt b/source/web/scripts/ajax/dojo/src/data/old/to_do.txt
new file mode 100644
index 0000000000..6e705fc6c3
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/data/old/to_do.txt
@@ -0,0 +1,45 @@
+Existing Features
+ * can import data from .json or .csv format files
+ * can import data from del.icio.us
+ * can create and modify data programmatically
+ * can bind data to dojo.widget.Chart
+ * can bind data to dojo.widget.SortableTable
+ * can bind one data set to multiple widgets
+ * notifications: widgets are notified when data changes
+ * notification available per-item or per-resultSet
+ * can create ad-hoc attributes
+ * attributes can be loosely-typed
+ * attributes can have meta-data like type and display name
+ * half-implemented support for sorting
+ * half-implemented support for export to .json
+ * API for getting data in simple arrays
+ * API for getting ResultSets with iterators (precursor to support for something like the openrico.org live grid)
+
+~~~~~~~~~~~~~~~~~~~~~~~~
+To-Do List
+ * be able to import data from an html
+ * think about being able to import data from some type of XML
+ * think about integration with dojo.undo.Manager
+ * think more about how to represent the notion of different data types
+ * think about what problems we'll run into when we have a MySQL data provider
+ * in TableBindingHack, improve support for data types in the SortableTable binding
+ * deal with ids (including MySQL multi-field keys)
+ * add support for item-references: employeeItem.set('department', departmentItem);
+ * deal with Attributes as instances of Items, not just subclasses of Items
+ * unit tests for compare/sort code
+ * unit tests for everything
+ * implement item.toString('json') and item.toString('xml')
+ * implement dataProvider.newItem({name: 'foo', age: 26})
+ * deal better with transactions
+ * add support for deleting items
+ * don't send out multiple notifications to the same observer
+ * deal with item versions
+ * prototype a Yahoo data provider -- http://developer.yahoo.net/common/json.html
+ * prototype a data provider that enforces strong typing
+ * prototype a data provider that prevents ad-hoc attributes
+ * prototype a data provider that enforces single-kind item
+ * prototype a data provider that allows for login/authentication
+ * have loosely typed result sets play nicely with widgets that expect strong typing
+ * prototype an example of spreadsheet-style formulas or derivation rules
+ * experiment with some sort of fetch() that returns only a subset of a data provider's items
+
diff --git a/source/web/scripts/ajax/dojo/src/date.js b/source/web/scripts/ajax/dojo/src/date.js
new file mode 100644
index 0000000000..7754095ff4
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/date.js
@@ -0,0 +1,13 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.date");
+
+dojo.deprecated("dojo.date", "use one of the modules in dojo.date.* instead", "0.5");
diff --git a/source/web/scripts/ajax/dojo/src/date/common.js b/source/web/scripts/ajax/dojo/src/date/common.js
new file mode 100644
index 0000000000..43c26eb740
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/date/common.js
@@ -0,0 +1,496 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.date.common");
+
+
+/* Supplementary Date Functions
+ *******************************/
+
+dojo.date.setDayOfYear = function(/*Date*/dateObject, /*Number*/dayOfYear){
+ // summary: sets dateObject according to day of the year (1..366)
+ dateObject.setMonth(0);
+ dateObject.setDate(dayOfYear);
+ return dateObject; // Date
+}
+
+dojo.date.getDayOfYear = function(/*Date*/dateObject){
+ // summary: gets the day of the year as represented by dateObject
+ var fullYear = dateObject.getFullYear();
+ var lastDayOfPrevYear = new Date(fullYear-1, 11, 31);
+ return Math.floor((dateObject.getTime() -
+ lastDayOfPrevYear.getTime()) / 86400000); // Number
+}
+
+
+dojo.date.setWeekOfYear = function(/*Date*/dateObject, /*Number*/week, /*Number*/firstDay){
+ if(arguments.length == 1){ firstDay = 0; } // Sunday
+ dojo.unimplemented("dojo.date.setWeekOfYear");
+}
+
+dojo.date.getWeekOfYear = function(/*Date*/dateObject, /*Number*/firstDay){
+ if(arguments.length == 1){ firstDay = 0; } // Sunday
+
+ // work out the first day of the year corresponding to the week
+ var firstDayOfYear = new Date(dateObject.getFullYear(), 0, 1);
+ var day = firstDayOfYear.getDay();
+ firstDayOfYear.setDate(firstDayOfYear.getDate() -
+ day + firstDay - (day > firstDay ? 7 : 0));
+
+ return Math.floor((dateObject.getTime() -
+ firstDayOfYear.getTime()) / 604800000);
+}
+
+dojo.date.setIsoWeekOfYear = function(/*Date*/dateObject, /*Number*/week, /*Number*/firstDay){
+ // summary: unimplemented
+ if (arguments.length == 1) { firstDay = 1; } // Monday
+ dojo.unimplemented("dojo.date.setIsoWeekOfYear");
+}
+
+dojo.date.getIsoWeekOfYear = function(/*Date*/dateObject, /*Number*/firstDay) {
+ // summary: unimplemented
+ if (arguments.length == 1) { firstDay = 1; } // Monday
+ dojo.unimplemented("dojo.date.getIsoWeekOfYear");
+}
+
+
+/* Informational Functions
+ **************************/
+
+//DEPRECATED: These timezone arrays will be deprecated in 0.5
+dojo.date.shortTimezones = ["IDLW", "BET", "HST", "MART", "AKST", "PST", "MST",
+ "CST", "EST", "AST", "NFT", "BST", "FST", "AT", "GMT", "CET", "EET", "MSK",
+ "IRT", "GST", "AFT", "AGTT", "IST", "NPT", "ALMT", "MMT", "JT", "AWST",
+ "JST", "ACST", "AEST", "LHST", "VUT", "NFT", "NZT", "CHAST", "PHOT",
+ "LINT"];
+dojo.date.timezoneOffsets = [-720, -660, -600, -570, -540, -480, -420, -360,
+ -300, -240, -210, -180, -120, -60, 0, 60, 120, 180, 210, 240, 270, 300,
+ 330, 345, 360, 390, 420, 480, 540, 570, 600, 630, 660, 690, 720, 765, 780,
+ 840];
+/*
+dojo.date.timezones = ["International Date Line West", "Bering Standard Time",
+ "Hawaiian Standard Time", "Marquesas Time", "Alaska Standard Time",
+ "Pacific Standard Time (USA)", "Mountain Standard Time",
+ "Central Standard Time (USA)", "Eastern Standard Time (USA)",
+ "Atlantic Standard Time", "Newfoundland Time", "Brazil Standard Time",
+ "Fernando de Noronha Standard Time (Brazil)", "Azores Time",
+ "Greenwich Mean Time", "Central Europe Time", "Eastern Europe Time",
+ "Moscow Time", "Iran Standard Time", "Gulf Standard Time",
+ "Afghanistan Time", "Aqtobe Time", "Indian Standard Time", "Nepal Time",
+ "Almaty Time", "Myanmar Time", "Java Time",
+ "Australian Western Standard Time", "Japan Standard Time",
+ "Australian Central Standard Time", "Lord Hove Standard Time (Australia)",
+ "Vanuata Time", "Norfolk Time (Australia)", "New Zealand Standard Time",
+ "Chatham Standard Time (New Zealand)", "Phoenix Islands Time (Kribati)",
+ "Line Islands Time (Kribati)"];
+*/
+
+dojo.date.getDaysInMonth = function(/*Date*/dateObject){
+ // summary: returns the number of days in the month used by dateObject
+ var month = dateObject.getMonth();
+ var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+ if (month == 1 && dojo.date.isLeapYear(dateObject)) { return 29; } // Number
+ else { return days[month]; } // Number
+}
+
+dojo.date.isLeapYear = function(/*Date*/dateObject){
+// summary:
+// Determines if the year of the dateObject is a leap year
+//
+// description:
+// Leap years are years with an additional day YYYY-02-29, where the year
+// number is a multiple of four with the following exception: If a year
+// is a multiple of 100, then it is only a leap year if it is also a
+// multiple of 400. For example, 1900 was not a leap year, but 2000 is one.
+
+ var year = dateObject.getFullYear();
+ return (year%400 == 0) ? true : (year%100 == 0) ? false : (year%4 == 0) ? true : false; // Boolean
+}
+
+// FIXME: This is not localized
+dojo.date.getTimezoneName = function(/*Date*/dateObject){
+// summary:
+// Get the user's time zone as provided by the browser
+//
+// dateObject: needed because the timezone may vary with time (daylight savings)
+//
+// description:
+// Try to get time zone info from toString or toLocaleString
+// method of the Date object -- UTC offset is not a time zone.
+// See http://www.twinsun.com/tz/tz-link.htm
+// Note: results may be inconsistent across browsers.
+
+ var str = dateObject.toString(); // Start looking in toString
+ var tz = ''; // The result -- return empty string if nothing found
+ var match;
+
+ // First look for something in parentheses -- fast lookup, no regex
+ var pos = str.indexOf('(');
+ if (pos > -1) {
+ pos++;
+ tz = str.substring(pos, str.indexOf(')'));
+ }
+ // If at first you don't succeed ...
+ else{
+ // If IE knows about the TZ, it appears before the year
+ // Capital letters or slash before a 4-digit year
+ // at the end of string
+ var pat = /([A-Z\/]+) \d{4}$/;
+ if((match = str.match(pat))) {
+ tz = match[1];
+ }
+ // Some browsers (e.g. Safari) glue the TZ on the end
+ // of toLocaleString instead of putting it in toString
+ else{
+ str = dateObject.toLocaleString();
+ // Capital letters or slash -- end of string,
+ // after space
+ pat = / ([A-Z\/]+)$/;
+ if((match = str.match(pat))) {
+ tz = match[1];
+ }
+ }
+ }
+
+ // Make sure it doesn't somehow end up return AM or PM
+ return tz == 'AM' || tz == 'PM' ? '' : tz; //String
+}
+
+
+//FIXME: not localized
+dojo.date.getOrdinal = function(dateObject){
+ // summary: returns the appropriate suffix (English only) for the day of the month, e.g. 'st' for 1, 'nd' for 2, etc.)
+ var date = dateObject.getDate();
+
+ if(date%100 != 11 && date%10 == 1){ return "st"; } // String
+ else if(date%100 != 12 && date%10 == 2){ return "nd"; } // String
+ else if(date%100 != 13 && date%10 == 3){ return "rd"; } // String
+ else{ return "th"; } // String
+}
+
+
+/* compare and add
+ ******************/
+dojo.date.compareTypes={
+ // summary
+ // bitmask for comparison operations.
+ DATE:1, TIME:2
+};
+dojo.date.compare=function(/* Date */ dateA, /* Date */ dateB, /* dojo.date.compareTypes */ options){
+ // summary
+ // Compare two date objects by date, time, or both. Returns 0 if equal, positive if a > b, else negative.
+ var dA=dateA;
+ var dB=dateB||new Date();
+ var now=new Date();
+ //FIXME: shorten this code
+ with(dojo.date.compareTypes){
+ var opt=options||(DATE|TIME);
+ var d1=new Date(
+ (opt&DATE)?dA.getFullYear():now.getFullYear(),
+ (opt&DATE)?dA.getMonth():now.getMonth(),
+ (opt&DATE)?dA.getDate():now.getDate(),
+ (opt&TIME)?dA.getHours():0,
+ (opt&TIME)?dA.getMinutes():0,
+ (opt&TIME)?dA.getSeconds():0
+ );
+ var d2=new Date(
+ (opt&DATE)?dB.getFullYear():now.getFullYear(),
+ (opt&DATE)?dB.getMonth():now.getMonth(),
+ (opt&DATE)?dB.getDate():now.getDate(),
+ (opt&TIME)?dB.getHours():0,
+ (opt&TIME)?dB.getMinutes():0,
+ (opt&TIME)?dB.getSeconds():0
+ );
+ }
+ if(d1.valueOf()>d2.valueOf()){
+ return 1; // int
+ }
+ if(d1.valueOf() 0) ? 5 : -5;
+ weeks = (incr > 0) ? ((incr-5)/5) : ((incr+5)/5);
+ }
+ else {
+ days = mod;
+ weeks = parseInt(incr/5);
+ }
+ // Get weekday value for orig date param
+ strt = dt.getDay();
+ // Orig date is Sat / positive incrementer
+ // Jump over Sun
+ if (strt == 6 && incr > 0) {
+ adj = 1;
+ }
+ // Orig date is Sun / negative incrementer
+ // Jump back over Sat
+ else if (strt == 0 && incr < 0) {
+ adj = -1;
+ }
+ // Get weekday val for the new date
+ trgt = (strt + days);
+ // New date is on Sat or Sun
+ if (trgt == 0 || trgt == 6) {
+ adj = (incr > 0) ? 2 : -2;
+ }
+ // Increment by number of weeks plus leftover days plus
+ // weekend adjustments
+ sum.setDate(dat + (7*weeks) + days + adj);
+ break;
+ case HOUR:
+ sum.setHours(sum.getHours()+incr);
+ break;
+ case MINUTE:
+ sum.setMinutes(sum.getMinutes()+incr);
+ break;
+ case SECOND:
+ sum.setSeconds(sum.getSeconds()+incr);
+ break;
+ case MILLISECOND:
+ sum.setMilliseconds(sum.getMilliseconds()+incr);
+ break;
+ default:
+ // Do nothing
+ break;
+ }
+ }
+
+ return sum; // Date
+};
+
+dojo.date.diff = function(/* Date */ dtA, /* Date */ dtB, /* dojo.date.dateParts */ interv){
+// summary:
+// Get the difference in a specific unit of time (e.g., number of months, weeks,
+// days, etc.) between two dates.
+//
+// dtA:
+// A Javascript Date object
+//
+// dtB:
+// A Javascript Date object
+//
+// interv:
+// A constant representing the interval, e.g. YEAR, MONTH, DAY. See dojo.date.dateParts.
+
+ // Accept timestamp input
+ if(typeof dtA == 'number'){dtA = new Date(dtA);}
+ if(typeof dtB == 'number'){dtB = new Date(dtB);}
+ var yeaDiff = dtB.getFullYear() - dtA.getFullYear();
+ var monDiff = (dtB.getMonth() - dtA.getMonth()) + (yeaDiff * 12);
+ var msDiff = dtB.getTime() - dtA.getTime(); // Millisecs
+ var secDiff = msDiff/1000;
+ var minDiff = secDiff/60;
+ var houDiff = minDiff/60;
+ var dayDiff = houDiff/24;
+ var weeDiff = dayDiff/7;
+ var delta = 0; // Integer return value
+
+ with(dojo.date.dateParts){
+ switch(interv){
+ case YEAR:
+ delta = yeaDiff;
+ break;
+ case QUARTER:
+ var mA = dtA.getMonth();
+ var mB = dtB.getMonth();
+ // Figure out which quarter the months are in
+ var qA = Math.floor(mA/3) + 1;
+ var qB = Math.floor(mB/3) + 1;
+ // Add quarters for any year difference between the dates
+ qB += (yeaDiff * 4);
+ delta = qB - qA;
+ break;
+ case MONTH:
+ delta = monDiff;
+ break;
+ case WEEK:
+ // Truncate instead of rounding
+ // Don't use Math.floor -- value may be negative
+ delta = parseInt(weeDiff);
+ break;
+ case DAY:
+ delta = dayDiff;
+ break;
+ case WEEKDAY:
+ var days = Math.round(dayDiff);
+ var weeks = parseInt(days/7);
+ var mod = days % 7;
+
+ // Even number of weeks
+ if (mod == 0) {
+ days = weeks*5;
+ }
+ // Weeks plus spare change (< 7 days)
+ else {
+ var adj = 0;
+ var aDay = dtA.getDay();
+ var bDay = dtB.getDay();
+
+ weeks = parseInt(days/7);
+ mod = days % 7;
+ // Mark the date advanced by the number of
+ // round weeks (may be zero)
+ var dtMark = new Date(dtA);
+ dtMark.setDate(dtMark.getDate()+(weeks*7));
+ var dayMark = dtMark.getDay();
+ // Spare change days -- 6 or less
+ // ----------
+ // Positive diff
+ if (dayDiff > 0) {
+ switch (true) {
+ // Range starts on Sat
+ case aDay == 6:
+ adj = -1;
+ break;
+ // Range starts on Sun
+ case aDay == 0:
+ adj = 0;
+ break;
+ // Range ends on Sat
+ case bDay == 6:
+ adj = -1;
+ break;
+ // Range ends on Sun
+ case bDay == 0:
+ adj = -2;
+ break;
+ // Range contains weekend
+ case (dayMark + mod) > 5:
+ adj = -2;
+ break;
+ default:
+ // Do nothing
+ break;
+ }
+ }
+ // Negative diff
+ else if (dayDiff < 0) {
+ switch (true) {
+ // Range starts on Sat
+ case aDay == 6:
+ adj = 0;
+ break;
+ // Range starts on Sun
+ case aDay == 0:
+ adj = 1;
+ break;
+ // Range ends on Sat
+ case bDay == 6:
+ adj = 2;
+ break;
+ // Range ends on Sun
+ case bDay == 0:
+ adj = 1;
+ break;
+ // Range contains weekend
+ case (dayMark + mod) < 0:
+ adj = 2;
+ break;
+ default:
+ // Do nothing
+ break;
+ }
+ }
+ days += adj;
+ days -= (weeks*2);
+ }
+ delta = days;
+
+ break;
+ case HOUR:
+ delta = houDiff;
+ break;
+ case MINUTE:
+ delta = minDiff;
+ break;
+ case SECOND:
+ delta = secDiff;
+ break;
+ case MILLISECOND:
+ delta = msDiff;
+ break;
+ default:
+ // Do nothing
+ break;
+ }
+ }
+
+ // Round for fractional values and DST leaps
+ return Math.round(delta); // Number (integer)
+};
diff --git a/source/web/scripts/ajax/dojo/src/date/format.js b/source/web/scripts/ajax/dojo/src/date/format.js
new file mode 100644
index 0000000000..4318525c83
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/date/format.js
@@ -0,0 +1,922 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.date.format");
+
+dojo.require("dojo.date.common");
+dojo.require("dojo.date.supplemental");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.lang.common");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.string.common");
+dojo.require("dojo.i18n.common");
+
+// Load the bundles containing localization information for
+// names and formats
+dojo.requireLocalization("dojo.i18n.calendar", "gregorian", null, "de,en,es,fi,fr,hu,ja,it,ko,nl,pt,sv,zh,pt-br,zh-cn,zh-hk,zh-tw,ROOT");
+dojo.requireLocalization("dojo.i18n.calendar", "gregorianExtras", null, "ja,zh,ROOT");
+
+//NOTE: Everything in this module assumes Gregorian calendars.
+// Other calendars will be implemented in separate modules.
+
+(function(){
+dojo.date.format = function(/*Date*/dateObject, /*Object?*/options){
+//
+// summary:
+// Format a Date object as a String, using locale-specific settings.
+//
+// description:
+// Create a string from a Date object using a known localized pattern.
+// By default, this method formats both date and time from dateObject.
+// Formatting patterns are chosen appropriate to the locale. Different
+// formatting lengths may be chosen, with "full" used by default.
+// Custom patterns may be used or registered with translations using
+// the addCustomBundle method.
+// Formatting patterns are implemented using the syntax described at
+// http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns
+//
+// dateObject:
+// the date and/or time to be formatted. If a time only is formatted,
+// the values in the year, month, and day fields are irrelevant. The
+// opposite is true when formatting only dates.
+//
+// options: object {selector: string, formatLength: string, datePattern: string, timePattern: string, locale: string}
+// selector- choice of timeOnly,dateOnly (default: date and time)
+// formatLength- choice of long, short, medium or full (plus any custom additions). Defaults to 'full'
+// datePattern,timePattern- override pattern with this string
+// am,pm- override strings for am/pm in times
+// locale- override the locale used to determine formatting rules
+//
+
+ if(typeof options == "string"){
+ dojo.deprecated("dojo.date.format", "To format dates with POSIX-style strings, please use dojo.date.strftime instead", "0.5");
+ return dojo.date.strftime(dateObject, options);
+ }
+
+ // Format a pattern without literals
+ function formatPattern(dateObject, pattern){
+ return pattern.replace(/([a-z])\1*/ig, function(match){
+ var s;
+ var c = match.charAt(0);
+ var l = match.length;
+ var pad;
+ var widthList = ["abbr", "wide", "narrow"];
+ switch(c){
+ case 'G':
+ if(l>3){dojo.unimplemented("Era format not implemented");}
+ s = info.eras[dateObject.getFullYear() < 0 ? 1 : 0];
+ break;
+ case 'y':
+ s = dateObject.getFullYear();
+ switch(l){
+ case 1:
+ break;
+ case 2:
+ s = String(s).substr(-2);
+ break;
+ default:
+ pad = true;
+ }
+ break;
+ case 'Q':
+ case 'q':
+ s = Math.ceil((dateObject.getMonth()+1)/3);
+ switch(l){
+ case 1: case 2:
+ pad = true;
+ break;
+ case 3:
+ case 4:
+ dojo.unimplemented("Quarter format not implemented");
+ }
+ break;
+ case 'M':
+ case 'L':
+ var m = dateObject.getMonth();
+ var width;
+ switch(l){
+ case 1: case 2:
+ s = m+1; pad = true;
+ break;
+ case 3: case 4: case 5:
+ width = widthList[l-3];
+ break;
+ }
+ if(width){
+ var type = (c == "L") ? "standalone" : "format";
+ var prop = ["months",type,width].join("-");
+ s = info[prop][m];
+ }
+ break;
+ case 'w':
+ var firstDay = 0;
+ s = dojo.date.getWeekOfYear(dateObject, firstDay); pad = true;
+ break;
+ case 'd':
+ s = dateObject.getDate(); pad = true;
+ break;
+ case 'D':
+ s = dojo.date.getDayOfYear(dateObject); pad = true;
+ break;
+ case 'E':
+ case 'e':
+ case 'c': // REVIEW: don't see this in the spec?
+ var d = dateObject.getDay();
+ var width;
+ switch(l){
+ case 1: case 2:
+ if(c == 'e'){
+ var first = dojo.date.getFirstDayOfWeek(options.locale);
+ d = (d-first+7)%7;
+ }
+ if(c != 'c'){
+ s = d+1; pad = true;
+ break;
+ }
+ // else fallthrough...
+ case 3: case 4: case 5:
+ width = widthList[l-3];
+ break;
+ }
+ if(width){
+ var type = (c == "c") ? "standalone" : "format";
+ var prop = ["days",type,width].join("-");
+ s = info[prop][d];
+ }
+ break;
+ case 'a':
+ var timePeriod = (dateObject.getHours() < 12) ? 'am' : 'pm';
+ s = info[timePeriod];
+ break;
+ case 'h':
+ case 'H':
+ case 'K':
+ case 'k':
+ var h = dateObject.getHours();
+ // strange choices in the date format make it impossible to write this succinctly
+ switch (c) {
+ case 'h': // 1-12
+ s = (h % 12) || 12;
+ break;
+ case 'H': // 0-23
+ s = h;
+ break;
+ case 'K': // 0-11
+ s = (h % 12);
+ break;
+ case 'k': // 1-24
+ s = h || 24;
+ break;
+ }
+ pad = true;
+ break;
+ case 'm':
+ s = dateObject.getMinutes(); pad = true;
+ break;
+ case 's':
+ s = dateObject.getSeconds(); pad = true;
+ break;
+ case 'S':
+ s = Math.round(dateObject.getMilliseconds() * Math.pow(10, l-3));
+ break;
+ case 'v': // FIXME: don't know what this is. seems to be same as z?
+ case 'z':
+ // We only have one timezone to offer; the one from the browser
+ s = dojo.date.getTimezoneName(dateObject);
+ if(s){break;}
+ l=4;
+ // fallthrough... use GMT if tz not available
+ case 'Z':
+ var offset = dateObject.getTimezoneOffset();
+ var tz = [
+ (offset<=0 ? "+" : "-"),
+ dojo.string.pad(Math.floor(Math.abs(offset)/60), 2),
+ dojo.string.pad(Math.abs(offset)% 60, 2)
+ ];
+ if(l==4){
+ tz.splice(0, 0, "GMT");
+ tz.splice(3, 0, ":");
+ }
+ s = tz.join("");
+ break;
+ case 'Y':
+ case 'u':
+ case 'W':
+ case 'F':
+ case 'g':
+ case 'A':
+ dojo.debug(match+" modifier not yet implemented");
+ s = "?";
+ break;
+ default:
+ dojo.raise("dojo.date.format: invalid pattern char: "+pattern);
+ }
+ if(pad){ s = dojo.string.pad(s, l); }
+ return s;
+ });
+ }
+
+ options = options || {};
+
+ var locale = dojo.hostenv.normalizeLocale(options.locale);
+ var formatLength = options.formatLength || 'full';
+ var info = dojo.date._getGregorianBundle(locale);
+ var str = [];
+ var sauce = dojo.lang.curry(this, formatPattern, dateObject);
+ if(options.selector != "timeOnly"){
+ var datePattern = options.datePattern || info["dateFormat-"+formatLength];
+ if(datePattern){str.push(_processPattern(datePattern, sauce));}
+ }
+ if(options.selector != "dateOnly"){
+ var timePattern = options.timePattern || info["timeFormat-"+formatLength];
+ if(timePattern){str.push(_processPattern(timePattern, sauce));}
+ }
+ var result = str.join(" "); //TODO: use locale-specific pattern to assemble date + time
+ return result; /*String*/
+};
+
+dojo.date.parse = function(/*String*/value, /*Object?*/options){
+//
+// summary:
+// Convert a properly formatted string to a primitive Date object,
+// using locale-specific settings.
+//
+// description:
+// Create a Date object from a string using a known localized pattern.
+// By default, this method parses looking for both date and time in the string.
+// Formatting patterns are chosen appropriate to the locale. Different
+// formatting lengths may be chosen, with "full" used by default.
+// Custom patterns may be used or registered with translations using
+// the addCustomBundle method.
+// Formatting patterns are implemented using the syntax described at
+// http://www.unicode.org/reports/tr35/#Date_Format_Patterns
+//
+// value:
+// A string representation of a date
+//
+// options: object {selector: string, formatLength: string, datePattern: string, timePattern: string, locale: string, strict: boolean}
+// selector- choice of timeOnly, dateOnly, dateTime (default: dateOnly)
+// formatLength- choice of long, short, medium or full (plus any custom additions). Defaults to 'full'
+// datePattern,timePattern- override pattern with this string
+// am,pm- override strings for am/pm in times
+// locale- override the locale used to determine formatting rules
+// strict- strict parsing, off by default
+//
+
+ options = options || {};
+ var locale = dojo.hostenv.normalizeLocale(options.locale);
+ var info = dojo.date._getGregorianBundle(locale);
+ var formatLength = options.formatLength || 'full';
+ if(!options.selector){ options.selector = 'dateOnly'; }
+ var datePattern = options.datePattern || info["dateFormat-" + formatLength];
+ var timePattern = options.timePattern || info["timeFormat-" + formatLength];
+
+ var pattern;
+ if(options.selector == 'dateOnly'){
+ pattern = datePattern;
+ }
+ else if(options.selector == 'timeOnly'){
+ pattern = timePattern;
+ }else if(options.selector == 'dateTime'){
+ pattern = datePattern + ' ' + timePattern; //TODO: use locale-specific pattern to assemble date + time
+ }else{
+ var msg = "dojo.date.parse: Unknown selector param passed: '" + options.selector + "'.";
+ msg += " Defaulting to date pattern.";
+ dojo.debug(msg);
+ pattern = datePattern;
+ }
+
+ var groups = [];
+ var dateREString = _processPattern(pattern, dojo.lang.curry(this, _buildDateTimeRE, groups, info, options));
+ var dateRE = new RegExp("^" + dateREString + "$");
+
+ var match = dateRE.exec(value);
+ if(!match){
+ return null;
+ }
+
+ var widthList = ['abbr', 'wide', 'narrow'];
+ //1972 is a leap year. We want to avoid Feb 29 rolling over into Mar 1,
+ //in the cases where the year is parsed after the month and day.
+ var result = new Date(1972, 0);
+ var expected = {};
+ for(var i=1; i2) {
+ if(!options.strict){
+ //Tolerate abbreviating period in month part
+ v = v.replace(/\./g,'');
+ //Case-insensitive
+ v = v.toLowerCase();
+ }
+ var months = info['months-format-' + widthList[l-3]].concat();
+ for (var j=0; j 15
+ } else if(v == am && hours == 12){
+ result.setHours(0); //12am -> 0
+ }
+ break;
+ case 'K': //hour (1-24)
+ if(v==24){v=0;}
+ // fallthrough...
+ case 'h': //hour (1-12)
+ case 'H': //hour (0-23)
+ case 'k': //hour (0-11)
+ //TODO: strict bounds checking, padding
+ if(v>23){
+ dojo.debug("dojo.date.parse: Illegal hours value");
+ return null;
+ }
+
+ //in the 12-hour case, adjusting for am/pm requires the 'a' part
+ //which for now we will assume always comes after the 'h' part
+ result.setHours(v);
+ break;
+ case 'm': //minutes
+ result.setMinutes(v);
+ break;
+ case 's': //seconds
+ result.setSeconds(v);
+ break;
+ case 'S': //milliseconds
+ result.setMilliseconds(v);
+ break;
+ default:
+ dojo.unimplemented("dojo.date.parse: unsupported pattern char=" + grp.charAt(0));
+ }
+ }
+
+ //validate parse date fields versus input date fields
+ if(expected.year && result.getFullYear() != expected.year){
+ dojo.debug("Parsed year: '" + result.getFullYear() + "' did not match input year: '" + expected.year + "'.");
+ return null;
+ }
+ if(expected.month && result.getMonth() != expected.month){
+ dojo.debug("Parsed month: '" + result.getMonth() + "' did not match input month: '" + expected.month + "'.");
+ return null;
+ }
+ if(expected.date && result.getDate() != expected.date){
+ dojo.debug("Parsed day of month: '" + result.getDate() + "' did not match input day of month: '" + expected.date + "'.");
+ return null;
+ }
+
+ //TODO: implement a getWeekday() method in order to test
+ //validity of input strings containing 'EEE' or 'EEEE'...
+
+ return result; /*Date*/
+};
+
+function _processPattern(pattern, applyPattern, applyLiteral, applyAll){
+ // Process a pattern with literals in it
+ // Break up on single quotes, treat every other one as a literal, except '' which becomes '
+ var identity = function(x){return x;};
+ applyPattern = applyPattern || identity;
+ applyLiteral = applyLiteral || identity;
+ applyAll = applyAll || identity;
+
+ //split on single quotes (which escape literals in date format strings)
+ //but preserve escaped single quotes (e.g., o''clock)
+ var chunks = pattern.match(/(''|[^'])+/g);
+ var literal = false;
+
+ for(var i=0; i2) ? '\\S+' : '\\d{1,2}';
+ break;
+ case 'd':
+ s = '\\d{1,2}';
+ break;
+ case 'E':
+ s = '\\S+';
+ break;
+ case 'h':
+ case 'H':
+ case 'K':
+ case 'k':
+ s = '\\d{1,2}';
+ break;
+ case 'm':
+ case 's':
+ s = '[0-5]\\d';
+ break;
+ case 'S':
+ s = '\\d{1,3}';
+ break;
+ case 'a':
+ var am = options.am || info.am || 'AM';
+ var pm = options.pm || info.pm || 'PM';
+ if(options.strict){
+ s = am + '|' + pm;
+ }else{
+ s = am;
+ s += (am != am.toLowerCase()) ? '|' + am.toLowerCase() : '';
+ s += '|';
+ s += (pm != pm.toLowerCase()) ? pm + '|' + pm.toLowerCase() : pm;
+ }
+ break;
+ default:
+ dojo.unimplemented("parse of date format, pattern=" + pattern);
+ }
+
+ if(groups){ groups.push(match); }
+
+//FIXME: replace whitespace within final regexp with more flexible whitespace match instead?
+ //tolerate whitespace
+ return '\\s*(' + s + ')\\s*';
+ });
+}
+})();
+
+//TODO: try to common strftime and format code somehow?
+
+dojo.date.strftime = function(/*Date*/dateObject, /*String*/format, /*String?*/locale){
+//
+// summary:
+// Formats the date object using the specifications of the POSIX strftime function
+//
+// description:
+// see
+
+ // zero pad
+ var padChar = null;
+ function _(s, n){
+ return dojo.string.pad(s, n || 2, padChar || "0");
+ }
+
+ var info = dojo.date._getGregorianBundle(locale);
+
+ function $(property){
+ switch (property){
+ case "a": // abbreviated weekday name according to the current locale
+ return dojo.date.getDayShortName(dateObject, locale);
+
+ case "A": // full weekday name according to the current locale
+ return dojo.date.getDayName(dateObject, locale);
+
+ case "b":
+ case "h": // abbreviated month name according to the current locale
+ return dojo.date.getMonthShortName(dateObject, locale);
+
+ case "B": // full month name according to the current locale
+ return dojo.date.getMonthName(dateObject, locale);
+
+ case "c": // preferred date and time representation for the current
+ // locale
+ return dojo.date.format(dateObject, {locale: locale});
+
+ case "C": // century number (the year divided by 100 and truncated
+ // to an integer, range 00 to 99)
+ return _(Math.floor(dateObject.getFullYear()/100));
+
+ case "d": // day of the month as a decimal number (range 01 to 31)
+ return _(dateObject.getDate());
+
+ case "D": // same as %m/%d/%y
+ return $("m") + "/" + $("d") + "/" + $("y");
+
+ case "e": // day of the month as a decimal number, a single digit is
+ // preceded by a space (range ' 1' to '31')
+ if(padChar == null){ padChar = " "; }
+ return _(dateObject.getDate());
+
+ case "f": // month as a decimal number, a single digit is
+ // preceded by a space (range ' 1' to '12')
+ if(padChar == null){ padChar = " "; }
+ return _(dateObject.getMonth()+1);
+
+ case "g": // like %G, but without the century.
+ break;
+
+ case "G": // The 4-digit year corresponding to the ISO week number
+ // (see %V). This has the same format and value as %Y,
+ // except that if the ISO week number belongs to the
+ // previous or next year, that year is used instead.
+ dojo.unimplemented("unimplemented modifier 'G'");
+ break;
+
+ case "F": // same as %Y-%m-%d
+ return $("Y") + "-" + $("m") + "-" + $("d");
+
+ case "H": // hour as a decimal number using a 24-hour clock (range
+ // 00 to 23)
+ return _(dateObject.getHours());
+
+ case "I": // hour as a decimal number using a 12-hour clock (range
+ // 01 to 12)
+ return _(dateObject.getHours() % 12 || 12);
+
+ case "j": // day of the year as a decimal number (range 001 to 366)
+ return _(dojo.date.getDayOfYear(dateObject), 3);
+
+ case "k": // Hour as a decimal number using a 24-hour clock (range
+ // 0 to 23 (space-padded))
+ if (padChar == null) { padChar = " "; }
+ return _(dateObject.getHours());
+
+ case "l": // Hour as a decimal number using a 12-hour clock (range
+ // 1 to 12 (space-padded))
+ if (padChar == null) { padChar = " "; }
+ return _(dateObject.getHours() % 12 || 12);
+
+ case "m": // month as a decimal number (range 01 to 12)
+ return _(dateObject.getMonth() + 1);
+
+ case "M": // minute as a decimal number
+ return _(dateObject.getMinutes());
+
+ case "n":
+ return "\n";
+
+ case "p": // either `am' or `pm' according to the given time value,
+ // or the corresponding strings for the current locale
+ return info[dateObject.getHours() < 12 ? "am" : "pm"];
+
+ case "r": // time in a.m. and p.m. notation
+ return $("I") + ":" + $("M") + ":" + $("S") + " " + $("p");
+
+ case "R": // time in 24 hour notation
+ return $("H") + ":" + $("M");
+
+ case "S": // second as a decimal number
+ return _(dateObject.getSeconds());
+
+ case "t":
+ return "\t";
+
+ case "T": // current time, equal to %H:%M:%S
+ return $("H") + ":" + $("M") + ":" + $("S");
+
+ case "u": // weekday as a decimal number [1,7], with 1 representing
+ // Monday
+ return String(dateObject.getDay() || 7);
+
+ case "U": // week number of the current year as a decimal number,
+ // starting with the first Sunday as the first day of the
+ // first week
+ return _(dojo.date.getWeekOfYear(dateObject));
+
+ case "V": // week number of the year (Monday as the first day of the
+ // week) as a decimal number [01,53]. If the week containing
+ // 1 January has four or more days in the new year, then it
+ // is considered week 1. Otherwise, it is the last week of
+ // the previous year, and the next week is week 1.
+ return _(dojo.date.getIsoWeekOfYear(dateObject));
+
+ case "W": // week number of the current year as a decimal number,
+ // starting with the first Monday as the first day of the
+ // first week
+ return _(dojo.date.getWeekOfYear(dateObject, 1));
+
+ case "w": // day of the week as a decimal, Sunday being 0
+ return String(dateObject.getDay());
+
+ case "x": // preferred date representation for the current locale
+ // without the time
+ return dojo.date.format(dateObject, {selector:'dateOnly', locale:locale});
+
+ case "X": // preferred time representation for the current locale
+ // without the date
+ return dojo.date.format(dateObject, {selector:'timeOnly', locale:locale});
+
+ case "y": // year as a decimal number without a century (range 00 to
+ // 99)
+ return _(dateObject.getFullYear()%100);
+
+ case "Y": // year as a decimal number including the century
+ return String(dateObject.getFullYear());
+
+ case "z": // time zone or name or abbreviation
+ var timezoneOffset = dateObject.getTimezoneOffset();
+ return (timezoneOffset > 0 ? "-" : "+") +
+ _(Math.floor(Math.abs(timezoneOffset)/60)) + ":" +
+ _(Math.abs(timezoneOffset)%60);
+
+ case "Z": // time zone or name or abbreviation
+ return dojo.date.getTimezoneName(dateObject);
+
+ case "%":
+ return "%";
+ }
+ }
+
+ // parse the formatting string and construct the resulting string
+ var string = "";
+ var i = 0;
+ var index = 0;
+ var switchCase = null;
+ while ((index = format.indexOf("%", i)) != -1){
+ string += format.substring(i, index++);
+
+ // inspect modifier flag
+ switch (format.charAt(index++)) {
+ case "_": // Pad a numeric result string with spaces.
+ padChar = " "; break;
+ case "-": // Do not pad a numeric result string.
+ padChar = ""; break;
+ case "0": // Pad a numeric result string with zeros.
+ padChar = "0"; break;
+ case "^": // Convert characters in result string to uppercase.
+ switchCase = "upper"; break;
+ case "*": // Convert characters in result string to lowercase
+ switchCase = "lower"; break;
+ case "#": // Swap the case of the result string.
+ switchCase = "swap"; break;
+ default: // no modifier flag so decrement the index
+ padChar = null; index--; break;
+ }
+
+ // toggle case if a flag is set
+ var property = $(format.charAt(index++));
+ switch (switchCase){
+ case "upper":
+ property = property.toUpperCase();
+ break;
+ case "lower":
+ property = property.toLowerCase();
+ break;
+ case "swap": // Upper to lower, and versey-vicea
+ var compareString = property.toLowerCase();
+ var swapString = '';
+ var j = 0;
+ var ch = '';
+ while (j < property.length){
+ ch = property.charAt(j);
+ swapString += (ch == compareString.charAt(j)) ?
+ ch.toUpperCase() : ch.toLowerCase();
+ j++;
+ }
+ property = swapString;
+ break;
+ default:
+ break;
+ }
+ switchCase = null;
+
+ string += property;
+ i = index;
+ }
+ string += format.substring(i);
+
+ return string; // String
+};
+
+(function(){
+var _customFormats = [];
+dojo.date.addCustomFormats = function(/*String*/packageName, /*String*/bundleName){
+//
+// summary:
+// Add a reference to a bundle containing localized custom formats to be
+// used by date/time formatting and parsing routines.
+//
+// description:
+// The user may add custom localized formats where the bundle has properties following the
+// same naming convention used by dojo for the CLDR data: dateFormat-xxxx / timeFormat-xxxx
+// The pattern string should match the format used by the CLDR.
+// See dojo.date.format for details.
+// The resources must be loaded by dojo.requireLocalization() prior to use
+
+ _customFormats.push({pkg:packageName,name:bundleName});
+};
+
+dojo.date._getGregorianBundle = function(/*String*/locale){
+ var gregorian = {};
+ dojo.lang.forEach(_customFormats, function(desc){
+ var bundle = dojo.i18n.getLocalization(desc.pkg, desc.name, locale);
+ gregorian = dojo.lang.mixin(gregorian, bundle);
+ }, this);
+ return gregorian; /*Object*/
+};
+})();
+
+dojo.date.addCustomFormats("dojo.i18n.calendar","gregorian");
+dojo.date.addCustomFormats("dojo.i18n.calendar","gregorianExtras");
+
+dojo.date.getNames = function(/*String*/item, /*String*/type, /*String?*/use, /*String?*/locale){
+//
+// summary:
+// Used to get localized strings for day or month names.
+//
+// item: 'months' || 'days'
+// type: 'wide' || 'narrow' || 'abbr' (e.g. "Monday", "Mon", or "M" respectively, in English)
+// use: 'standAlone' || 'format' (default)
+// locale: override locale used to find the names
+
+ var label;
+ var lookup = dojo.date._getGregorianBundle(locale);
+ var props = [item, use, type];
+ if(use == 'standAlone'){
+ label = lookup[props.join('-')];
+ }
+ props[1] = 'format';
+
+ // return by copy so changes won't be made accidentally to the in-memory model
+ return (label || lookup[props.join('-')]).concat(); /*Array*/
+};
+
+// Convenience methods
+
+dojo.date.getDayName = function(/*Date*/dateObject, /*String?*/locale){
+// summary: gets the full localized day of the week corresponding to the date object
+ return dojo.date.getNames('days', 'wide', 'format', locale)[dateObject.getDay()]; /*String*/
+};
+
+dojo.date.getDayShortName = function(/*Date*/dateObject, /*String?*/locale){
+// summary: gets the abbreviated localized day of the week corresponding to the date object
+ return dojo.date.getNames('days', 'abbr', 'format', locale)[dateObject.getDay()]; /*String*/
+};
+
+dojo.date.getMonthName = function(/*Date*/dateObject, /*String?*/locale){
+// summary: gets the full localized month name corresponding to the date object
+ return dojo.date.getNames('months', 'wide', 'format', locale)[dateObject.getMonth()]; /*String*/
+};
+
+dojo.date.getMonthShortName = function(/*Date*/dateObject, /*String?*/locale){
+// summary: gets the abbreviated localized month name corresponding to the date object
+ return dojo.date.getNames('months', 'abbr', 'format', locale)[dateObject.getMonth()]; /*String*/
+};
+
+//FIXME: not localized
+dojo.date.toRelativeString = function(/*Date*/dateObject){
+// summary:
+// Returns an description in English of the date relative to the current date. Note: this is not localized yet. English only.
+//
+// description: Example returns:
+// - "1 minute ago"
+// - "4 minutes ago"
+// - "Yesterday"
+// - "2 days ago"
+
+ var now = new Date();
+ var diff = (now - dateObject) / 1000;
+ var end = " ago";
+ var future = false;
+ if(diff < 0){
+ future = true;
+ end = " from now";
+ diff = -diff;
+ }
+
+ if(diff < 60){
+ diff = Math.round(diff);
+ return diff + " second" + (diff == 1 ? "" : "s") + end;
+ }
+ if(diff < 60*60){
+ diff = Math.round(diff/60);
+ return diff + " minute" + (diff == 1 ? "" : "s") + end;
+ }
+ if(diff < 60*60*24){
+ diff = Math.round(diff/3600);
+ return diff + " hour" + (diff == 1 ? "" : "s") + end;
+ }
+ if(diff < 60*60*24*7){
+ diff = Math.round(diff/(3600*24));
+ if(diff == 1){
+ return future ? "Tomorrow" : "Yesterday";
+ }else{
+ return diff + " days" + end;
+ }
+ }
+ return dojo.date.format(dateObject); // String
+};
+
+//FIXME: SQL methods can probably be moved to a different module without i18n deps
+
+dojo.date.toSql = function(/*Date*/dateObject, /*Boolean?*/noTime){
+// summary:
+// Convert a Date to a SQL string
+// noTime: whether to ignore the time portion of the Date. Defaults to false.
+
+ return dojo.date.strftime(dateObject, "%F" + !noTime ? " %T" : ""); // String
+};
+
+dojo.date.fromSql = function(/*String*/sqlDate){
+// summary:
+// Convert a SQL date string to a JavaScript Date object
+
+ var parts = sqlDate.split(/[\- :]/g);
+ while(parts.length < 6){
+ parts.push(0);
+ }
+ return new Date(parts[0], (parseInt(parts[1],10)-1), parts[2], parts[3], parts[4], parts[5]); // Date
+};
diff --git a/source/web/scripts/ajax/dojo/src/date/serialize.js b/source/web/scripts/ajax/dojo/src/date/serialize.js
new file mode 100644
index 0000000000..6a43f98634
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/date/serialize.js
@@ -0,0 +1,175 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.date.serialize");
+
+dojo.require("dojo.string.common");
+
+/* ISO 8601 Functions
+ *********************/
+
+dojo.date.setIso8601 = function(/*Date*/dateObject, /*String*/formattedString){
+ // summary: sets a Date object based on an ISO 8601 formatted string (uses date and time)
+ var comps = (formattedString.indexOf("T") == -1) ? formattedString.split(" ") : formattedString.split("T");
+ dateObject = dojo.date.setIso8601Date(dateObject, comps[0]);
+ if(comps.length == 2){ dateObject = dojo.date.setIso8601Time(dateObject, comps[1]); }
+ return dateObject; /* Date or null */
+};
+
+dojo.date.fromIso8601 = function(/*String*/formattedString){
+ // summary: returns a Date object based on an ISO 8601 formatted string (uses date and time)
+ return dojo.date.setIso8601(new Date(0, 0), formattedString);
+};
+
+dojo.date.setIso8601Date = function(/*String*/dateObject, /*String*/formattedString){
+ // summary: sets a Date object based on an ISO 8601 formatted string (date only)
+ var regexp = "^([0-9]{4})((-?([0-9]{2})(-?([0-9]{2}))?)|" +
+ "(-?([0-9]{3}))|(-?W([0-9]{2})(-?([1-7]))?))?$";
+ var d = formattedString.match(new RegExp(regexp));
+ if(!d){
+ dojo.debug("invalid date string: " + formattedString);
+ return null; // null
+ }
+ var year = d[1];
+ var month = d[4];
+ var date = d[6];
+ var dayofyear = d[8];
+ var week = d[10];
+ var dayofweek = d[12] ? d[12] : 1;
+
+ dateObject.setFullYear(year);
+
+ if(dayofyear){
+ dateObject.setMonth(0);
+ dateObject.setDate(Number(dayofyear));
+ }
+ else if(week){
+ dateObject.setMonth(0);
+ dateObject.setDate(1);
+ var gd = dateObject.getDay();
+ var day = gd ? gd : 7;
+ var offset = Number(dayofweek) + (7 * Number(week));
+
+ if(day <= 4){ dateObject.setDate(offset + 1 - day); }
+ else{ dateObject.setDate(offset + 8 - day); }
+ } else{
+ if(month){
+ dateObject.setDate(1);
+ dateObject.setMonth(month - 1);
+ }
+ if(date){ dateObject.setDate(date); }
+ }
+
+ return dateObject; // Date
+};
+
+dojo.date.fromIso8601Date = function(/*String*/formattedString){
+ // summary: returns a Date object based on an ISO 8601 formatted string (date only)
+ return dojo.date.setIso8601Date(new Date(0, 0), formattedString);
+};
+
+dojo.date.setIso8601Time = function(/*Date*/dateObject, /*String*/formattedString){
+ // summary: sets a Date object based on an ISO 8601 formatted string (time only)
+
+ // first strip timezone info from the end
+ var timezone = "Z|(([-+])([0-9]{2})(:?([0-9]{2}))?)$";
+ var d = formattedString.match(new RegExp(timezone));
+
+ var offset = 0; // local time if no tz info
+ if(d){
+ if(d[0] != 'Z'){
+ offset = (Number(d[3]) * 60) + Number(d[5]);
+ offset *= ((d[2] == '-') ? 1 : -1);
+ }
+ offset -= dateObject.getTimezoneOffset();
+ formattedString = formattedString.substr(0, formattedString.length - d[0].length);
+ }
+
+ // then work out the time
+ var regexp = "^([0-9]{2})(:?([0-9]{2})(:?([0-9]{2})(\.([0-9]+))?)?)?$";
+ d = formattedString.match(new RegExp(regexp));
+ if(!d){
+ dojo.debug("invalid time string: " + formattedString);
+ return null; // null
+ }
+ var hours = d[1];
+ var mins = Number((d[3]) ? d[3] : 0);
+ var secs = (d[5]) ? d[5] : 0;
+ var ms = d[7] ? (Number("0." + d[7]) * 1000) : 0;
+
+ dateObject.setHours(hours);
+ dateObject.setMinutes(mins);
+ dateObject.setSeconds(secs);
+ dateObject.setMilliseconds(ms);
+
+ if(offset !== 0){
+ dateObject.setTime(dateObject.getTime() + offset * 60000);
+ }
+ return dateObject; // Date
+};
+
+dojo.date.fromIso8601Time = function(/*String*/formattedString){
+ // summary: returns a Date object based on an ISO 8601 formatted string (date only)
+ return dojo.date.setIso8601Time(new Date(0, 0), formattedString);
+};
+
+
+/* RFC-3339 Date Functions
+ *************************/
+
+dojo.date.toRfc3339 = function(/*Date?*/dateObject, /*String?*/selector){
+// summary:
+// Format a JavaScript Date object as a string according to RFC 3339
+//
+// dateObject:
+// A JavaScript date, or the current date and time, by default
+//
+// selector:
+// "dateOnly" or "timeOnly" to format selected portions of the Date object.
+// Date and time will be formatted by default.
+
+//FIXME: tolerate Number, string input?
+ if(!dateObject){
+ dateObject = new Date();
+ }
+
+ var _ = dojo.string.pad;
+ var formattedDate = [];
+ if(selector != "timeOnly"){
+ var date = [_(dateObject.getFullYear(),4), _(dateObject.getMonth()+1,2), _(dateObject.getDate(),2)].join('-');
+ formattedDate.push(date);
+ }
+ if(selector != "dateOnly"){
+ var time = [_(dateObject.getHours(),2), _(dateObject.getMinutes(),2), _(dateObject.getSeconds(),2)].join(':');
+ var timezoneOffset = dateObject.getTimezoneOffset();
+ time += (timezoneOffset > 0 ? "-" : "+") +
+ _(Math.floor(Math.abs(timezoneOffset)/60),2) + ":" +
+ _(Math.abs(timezoneOffset)%60,2);
+ formattedDate.push(time);
+ }
+ return formattedDate.join('T'); // String
+};
+
+dojo.date.fromRfc3339 = function(/*String*/rfcDate){
+// summary:
+// Create a JavaScript Date object from a string formatted according to RFC 3339
+//
+// rfcDate:
+// A string such as 2005-06-30T08:05:00-07:00
+// "any" is also supported in place of a time.
+
+ // backwards compatible support for use of "any" instead of just not
+ // including the time
+ if(rfcDate.indexOf("Tany")!=-1){
+ rfcDate = rfcDate.replace("Tany","");
+ }
+ var dateObject = new Date();
+ return dojo.date.setIso8601(dateObject, rfcDate); // Date or null
+};
diff --git a/source/web/scripts/ajax/dojo/src/date/supplemental.js b/source/web/scripts/ajax/dojo/src/date/supplemental.js
new file mode 100644
index 0000000000..898c7f3dff
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/date/supplemental.js
@@ -0,0 +1,76 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.date.supplemental");
+
+dojo.date.getFirstDayOfWeek = function(/*String?*/locale){
+// summary: Returns a zero-based index for first day of the week
+// description:
+// Returns a zero-based index for first day of the week, as used by the local (Gregorian) calendar.
+// e.g. Sunday (returns 0), or Monday (returns 1)
+
+ // from http://www.unicode.org/cldr/data/common/supplemental/supplementalData.xml:supplementalData/weekData/firstDay
+ var firstDay = {/*default is 1=Monday*/
+ mv:5,
+ ae:6,af:6,bh:6,dj:6,dz:6,eg:6,er:6,et:6,iq:6,ir:6,jo:6,ke:6,kw:6,lb:6,ly:6,ma:6,om:6,qa:6,sa:6,
+ sd:6,so:6,tn:6,ye:6,
+ as:0,au:0,az:0,bw:0,ca:0,cn:0,fo:0,ge:0,gl:0,gu:0,hk:0,ie:0,il:0,is:0,jm:0,jp:0,kg:0,kr:0,la:0,
+ mh:0,mo:0,mp:0,mt:0,nz:0,ph:0,pk:0,sg:0,th:0,tt:0,tw:0,um:0,us:0,uz:0,vi:0,za:0,zw:0,
+ et:0,mw:0,ng:0,tj:0,
+ gb:0,
+ sy:4
+ };
+
+ locale = dojo.hostenv.normalizeLocale(locale);
+ var country = locale.split("-")[1];
+ var dow = firstDay[country];
+ return (typeof dow == 'undefined') ? 1 : dow; /*Number*/
+};
+
+dojo.date.getWeekend = function(/*String?*/locale){
+// summary: Returns a hash containing the start and end days of the weekend
+// description:
+// Returns a hash containing the start and end days of the weekend according to local custom using locale,
+// or by default in the user's locale.
+// e.g. {start:6, end:0}
+
+ // from http://www.unicode.org/cldr/data/common/supplemental/supplementalData.xml:supplementalData/weekData/weekend{Start,End}
+ var weekendStart = {/*default is 6=Saturday*/
+ eg:5,il:5,sy:5,
+ 'in':0,
+ ae:4,bh:4,dz:4,iq:4,jo:4,kw:4,lb:4,ly:4,ma:4,om:4,qa:4,sa:4,sd:4,tn:4,ye:4
+ };
+
+ var weekendEnd = {/*default is 0=Sunday*/
+ ae:5,bh:5,dz:5,iq:5,jo:5,kw:5,lb:5,ly:5,ma:5,om:5,qa:5,sa:5,sd:5,tn:5,ye:5,af:5,ir:5,
+ eg:6,il:6,sy:6
+ };
+
+ locale = dojo.hostenv.normalizeLocale(locale);
+ var country = locale.split("-")[1];
+ var start = weekendStart[country];
+ var end = weekendEnd[country];
+ if(typeof start == 'undefined'){start=6;}
+ if(typeof end == 'undefined'){end=0;}
+ return {start:start, end:end}; /*Object {start,end}*/
+};
+
+dojo.date.isWeekend = function(/*Date?*/dateObj, /*String?*/locale){
+// summary:
+// Determines if the date falls on a weekend, according to local custom.
+
+ var weekend = dojo.date.getWeekend(locale);
+ var day = (dateObj || new Date()).getDay();
+ if(weekend.end= weekend.start && day <= weekend.end; // Boolean
+};
diff --git a/source/web/scripts/ajax/dojo/src/debug.js b/source/web/scripts/ajax/dojo/src/debug.js
new file mode 100644
index 0000000000..337aaddc00
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/debug.js
@@ -0,0 +1,91 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.debug = function(/*...*/){
+ // summary:
+ // Produce a line of debug output. Does nothing unless
+ // djConfig.isDebug is true. Accepts any nubmer of args, joined with
+ // ' ' to produce a single line of debugging output. Caller should not
+ // supply a trailing "\n".
+ if (!djConfig.isDebug) { return; }
+ var args = arguments;
+ if(dj_undef("println", dojo.hostenv)){
+ dojo.raise("dojo.debug not available (yet?)");
+ }
+ var isJUM = dj_global["jum"] && !dj_global["jum"].isBrowser;
+ var s = [(isJUM ? "": "DEBUG: ")];
+ for(var i=0;i 0.4");
+ }
+}
diff --git a/source/web/scripts/ajax/dojo/src/debug/arrow_hide.gif b/source/web/scripts/ajax/dojo/src/debug/arrow_hide.gif
new file mode 100644
index 0000000000..8bd6b346ca
Binary files /dev/null and b/source/web/scripts/ajax/dojo/src/debug/arrow_hide.gif differ
diff --git a/source/web/scripts/ajax/dojo/src/debug/arrow_show.gif b/source/web/scripts/ajax/dojo/src/debug/arrow_show.gif
new file mode 100644
index 0000000000..4246b506fb
Binary files /dev/null and b/source/web/scripts/ajax/dojo/src/debug/arrow_show.gif differ
diff --git a/source/web/scripts/ajax/dojo/src/debug/console.js b/source/web/scripts/ajax/dojo/src/debug/console.js
new file mode 100644
index 0000000000..99bf32b3df
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/debug/console.js
@@ -0,0 +1,115 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.debug.console");
+dojo.require("dojo.logging.ConsoleLogger");
+
+// summary:
+// Console logger, for use with FireFox Firebug, Safari and Opera's consoles.
+// description:
+// This package redirects the normal dojo debugging output to the console log in modern browsers.
+// When using Firebug, it does this by sending the entire object to the console,
+// rather than just overriding dojo.hostenv.println, so that Firebug's interactive
+// object inspector is available.
+// see: http://www.joehewitt.com/software/firebug/docs.php
+
+if (window.console) {
+ if (console.info != null) {
+ // using a later version of Firebug -- lots of fun stuff!
+
+ dojo.hostenv.println = function() {
+ // summary: Write all of the arguments to the Firebug console
+ // description: Uses console.info() so that the (i) icon prints next to the debug line
+ // rather than munging the arguments by adding "DEBUG:" in front of them.
+ // This allows us to use Firebug's string handling to do interesting things
+ if (!djConfig.isDebug) { return; }
+ console.info.apply(console, arguments);
+ }
+ dojo.debug=dojo.hostenv.println;
+ dojo.debugDeep = dojo.debug;
+
+ dojo.debugShallow = function(/*Object*/ obj, /*Boolean?*/showMethods, /*Boolean?*/sort) {
+ // summary: Write first-level properties of obj to the console.
+ // obj: Object or Array to debug
+ // showMethods: Pass false to skip outputing methods of object, any other value will output them.
+ // sort: Pass false to skip sorting properties, any other value will sort.
+ if (!djConfig.isDebug) { return; }
+
+ showMethods = (showMethods != false);
+ sort = (sort != false);
+
+ // handle null or something without a constructor (in which case we don't know the type)
+ if (obj == null || obj.constructor == null) {
+ return dojo.debug(obj);
+ }
+
+ // figure out type via a standard constructor (Object, String, Date, etc)
+ var type = obj.declaredClass;
+ if (type == null) {
+ type = obj.constructor.toString().match(/function\s*(.*)\(/);
+ if (type) { type = type[1] };
+ }
+ // if we got a viable type, use Firebug's interactive property dump feature
+ if (type) {
+ if (type == "String" || type == "Number") {
+ return dojo.debug(type+": ", obj);
+ }
+ if (showMethods && !sort) {
+ var sortedObj = obj;
+ } else {
+ var propNames = [];
+ if (showMethods) {
+ for (var prop in obj) {
+ propNames.push(prop);
+ }
+ } else {
+ for (var prop in obj) {
+ if (typeof obj[prop] != "function") { propNames.push(prop); }
+ else dojo.debug(prop);
+ }
+ }
+ if (sort) propNames.sort();
+ var sortedObj = {};
+ dojo.lang.forEach(propNames, function(prop) {
+ sortedObj[prop] = obj[prop];
+ });
+ }
+
+ return dojo.debug(type+": %o\n%2.o",obj,sortedObj);
+ }
+
+ // otherwise just output the constructor + object,
+ // which is nice for a DOM element, etc
+ return dojo.debug(obj.constructor + ": ", obj);
+ }
+
+ } else if (console.log != null) {
+ // using Safari or an old version of Firebug
+ dojo.hostenv.println=function() {
+ if (!djConfig.isDebug) { return ; }
+ // make sure we're only writing a single string to Safari's console
+ var args = dojo.lang.toArray(arguments);
+ console.log("DEBUG: " + args.join(" "));
+ }
+ dojo.debug=dojo.hostenv.println;
+ } else {
+ // not supported
+ dojo.debug("dojo.debug.console requires Firebug > 0.4");
+ }
+} else if (dojo.render.html.opera) {
+ // using Opera 8.0 or later
+ if (opera && opera.postError) {
+ dojo.hostenv.println=opera.postError;
+ // summary: hook debugging up to Opera's postError routine
+ } else {
+ dojo.debug("dojo.debug.Opera requires Opera > 8.0");
+ }
+}
+
diff --git a/source/web/scripts/ajax/dojo/src/debug/deep.html b/source/web/scripts/ajax/dojo/src/debug/deep.html
new file mode 100644
index 0000000000..1a22fbfc45
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/debug/deep.html
@@ -0,0 +1,362 @@
+
+
+Deep Debugger
+
+
+
+
+
+Javascript Object Browser
+
+
+
+
+
\ No newline at end of file
diff --git a/source/web/scripts/ajax/dojo/src/debug/spacer.gif b/source/web/scripts/ajax/dojo/src/debug/spacer.gif
new file mode 100644
index 0000000000..2ce50b5867
Binary files /dev/null and b/source/web/scripts/ajax/dojo/src/debug/spacer.gif differ
diff --git a/source/web/scripts/ajax/dojo/src/dnd/DragAndDrop.js b/source/web/scripts/ajax/dojo/src/dnd/DragAndDrop.js
new file mode 100644
index 0000000000..f8ac37212c
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/dnd/DragAndDrop.js
@@ -0,0 +1,264 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.require("dojo.lang.common");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.lang.declare");
+dojo.provide("dojo.dnd.DragAndDrop");
+
+// summary:
+// Core "interfaces" for the participants in all DnD operations.
+// Subclasses implement all of the actions outlined by these APIs, with
+// most of the ones you probably care about being defined in
+// HtmlDragAndDrop.js, which will be automatically included should you
+// dojo.require("dojo.dnd.*");.
+//
+// In addition to the various actor classes, a global manager will be
+// created/installed at dojo.dnd.dragManager. This manager object is of
+// type dojo.dnd.DragManager and will be replaced by environment-specific
+// managers.
+//
+// The 3 object types involved in any Drag and Drop operation are:
+// * DragSource
+// This is the item that can be selected for dragging. Drag
+// sources can have "types" to help mediate whether or not various
+// DropTargets will accept (or reject them). Most dragging actions
+// are handled by the DragObject which the DragSource generates
+// from its onDragStart method.
+// * DragObject
+// This, along with the manger, does most of the hard work of DnD.
+// Implementations may rely on DragObject instances to implement
+// "shadowing", "movement", or other kinds of DnD variations that
+// affect the visual representation of the drag operation.
+// * DropTarget
+// Represents some section of the screen that can accept drag
+// and drop events. DropTargets keep a list of accepted types
+// which is checked agains the types of the respective DragSource
+// objects that pass over it. DropTargets may implement behaviors
+// that respond to drop events to take application-level actions.
+
+dojo.declare("dojo.dnd.DragSource", null, {
+ // String:
+ // what kind of drag source are we? Used to determine if we can be
+ // dropped on a given DropTarget
+ type: "",
+
+ onDragEnd: function(/*dojo.dnd.DragEvent*/evt){
+ // summary:
+ // stub handler that is called when dragging finishes.
+ },
+
+ onDragStart: function(/*dojo.dnd.DragEvent*/evt){ // dojo.dnd.DragObject
+ // summary:
+ // stub handler that is called when dragging starts. Subclasses
+ // should ensure that onDragStart *always* returns a
+ // dojo.dnd.DragObject instance.
+ },
+
+ onSelected: function(/*dojo.dnd.DragEvent*/evt){
+ // summary:
+ // This function gets called when the DOM element was selected for
+ // dragging by the HtmlDragAndDropManager.
+ },
+
+ unregister: function(){
+ // summary: remove this drag source from the manager
+ dojo.dnd.dragManager.unregisterDragSource(this);
+ },
+
+ reregister: function(){
+ // summary: add this drag source to the manager
+ dojo.dnd.dragManager.registerDragSource(this);
+ }
+});
+
+dojo.declare("dojo.dnd.DragObject", null, {
+ // String:
+ // what kind of drag object are we? Used to determine if we can be
+ // dropped on a given DropTarget
+ type: "",
+
+ register: function(){
+ // summary: register this DragObject with the manager
+ var dm = dojo.dnd.dragManager;
+ if(dm["registerDragObject"]){ // side-effect prevention
+ dm.registerDragObject(this);
+ }
+ },
+
+ onDragStart: function(/*dojo.dnd.DragEvent*/evt){
+ // summary:
+ // over-ridden by subclasses. Gets called directly after being
+ // created by the DragSource default action is to clone self as
+ // icon
+ },
+
+ onDragMove: function(/*dojo.dnd.DragEvent*/evt){
+ // summary:
+ // Implemented by subclasses. Should change the UI for the drag
+ // icon i.e., "it moves itself"
+ },
+
+ onDragOver: function(/*dojo.dnd.DragEvent*/evt){
+ // summary:
+ // stub handler that is called when the DragObject instance is
+ // "over" a DropTarget.
+ },
+
+ onDragOut: function(/*dojo.dnd.DragEvent*/evt){
+ // summary:
+ // stub handler that is called when the DragObject instance leaves
+ // a DropTarget.
+ },
+
+ onDragEnd: function(/*dojo.dnd.DragEvent*/evt){
+ // summary:
+ // stub handler that is called when dragging ends, either through
+ // dropping or cancelation.
+ },
+
+ // normal aliases
+ onDragLeave: dojo.lang.forward("onDragOut"),
+ onDragEnter: dojo.lang.forward("onDragOver"),
+
+ // non-camel aliases
+ ondragout: dojo.lang.forward("onDragOut"),
+ ondragover: dojo.lang.forward("onDragOver")
+});
+
+dojo.declare("dojo.dnd.DropTarget", null, {
+
+ acceptsType: function(/*String*/type){
+ // summary:
+ // determines whether or not this DropTarget will accept the given
+ // type. The default behavior is to consult this.acceptedTypes and
+ // if "*" is a member, to always accept the type.
+ if(!dojo.lang.inArray(this.acceptedTypes, "*")){ // wildcard
+ if(!dojo.lang.inArray(this.acceptedTypes, type)) { return false; } // Boolean
+ }
+ return true; // Boolean
+ },
+
+ accepts: function(/*Array*/dragObjects){
+ // summary:
+ // determines if we'll accept all members of the passed array of
+ // dojo.dnd.DragObject instances
+ if(!dojo.lang.inArray(this.acceptedTypes, "*")){ // wildcard
+ for (var i = 0; i < dragObjects.length; i++) {
+ if (!dojo.lang.inArray(this.acceptedTypes,
+ dragObjects[i].type)) { return false; } // Boolean
+ }
+ }
+ return true; // Boolean
+ },
+
+ unregister: function(){
+ // summary: remove from the drag manager
+ dojo.dnd.dragManager.unregisterDropTarget(this);
+ },
+
+ onDragOver: function(/*dojo.dnd.DragEvent*/evt){
+ // summary:
+ // stub handler that is called when DragObject instances are
+ // "over" this DropTarget.
+ },
+
+ onDragOut: function(/*dojo.dnd.DragEvent*/evt){
+ // summary:
+ // stub handler that is called when DragObject instances are
+ // "leave" this DropTarget.
+ },
+
+ onDragMove: function(/*dojo.dnd.DragEvent*/evt){
+ // summary:
+ // stub handler that is called when DragObject instances are
+ // moved across this DropTarget. May fire many times in the course
+ // of the drag operation but will end after onDragOut
+ },
+
+ onDropStart: function(/*dojo.dnd.DragEvent*/evt){ // Boolean
+ // summary:
+ // stub handler that is called when DragObject instances are
+ // dropped on this target. If true is returned from onDropStart,
+ // dropping proceeds, otherwise it's cancled.
+ },
+
+ onDrop: function(/*dojo.dnd.DragEvent*/evt){
+ // summary: we're getting dropped on!
+ },
+
+ onDropEnd: function(){
+ // summary: dropping is over
+ }
+}, function(){
+ this.acceptedTypes = [];
+});
+
+// NOTE: this interface is defined here for the convenience of the DragManager
+// implementor. It is expected that in most cases it will be satisfied by
+// extending a native event (DOM event in HTML and SVG).
+dojo.dnd.DragEvent = function(){
+ this.dragSource = null;
+ this.dragObject = null;
+ this.target = null;
+ this.eventStatus = "success";
+ //
+ // can be one of:
+ // [ "dropSuccess", "dropFailure", "dragMove",
+ // "dragStart", "dragEnter", "dragLeave"]
+ //
+}
+/*
+ * The DragManager handles listening for low-level events and dispatching
+ * them to higher-level primitives like drag sources and drop targets. In
+ * order to do this, it must keep a list of the items.
+ */
+dojo.declare("dojo.dnd.DragManager", null, {
+ // Array: an array of currently selected DragSource objects
+ selectedSources: [],
+ // Array: all DragObjects we know about
+ dragObjects: [],
+ // Array: all DragSources we know about
+ dragSources: [],
+ registerDragSource: function(/*dojo.dnd.DragSource*/ source){
+ // summary: called by DragSource class constructor
+ },
+ // Array: all DropTargets we know about
+ dropTargets: [],
+ registerDropTarget: function(/*dojo.dnd.DropTarget*/ target){
+ // summary: called by DropTarget class constructor
+ },
+ // dojo.dnd.DropTarget:
+ // what was the last DropTarget instance we left in the drag phase?
+ lastDragTarget: null,
+ // dojo.dnd.DropTarget:
+ // the DropTarget the mouse is currently over
+ currentDragTarget: null,
+ onKeyDown: function(){
+ // summary: generic handler called by low-level events
+ },
+ onMouseOut: function(){
+ // summary: generic handler called by low-level events
+ },
+ onMouseMove: function(){
+ // summary: generic handler called by low-level events
+ },
+ onMouseUp: function(){
+ // summary: generic handler called by low-level events
+ }
+});
+
+// NOTE: despite the existance of the DragManager class, there will be a
+// singleton drag manager provided by the renderer-specific D&D support code.
+// It is therefore sane for us to assign instance variables to the DragManager
+// prototype
+
+// The renderer-specific file will define the following object:
+// dojo.dnd.dragManager = null;
diff --git a/source/web/scripts/ajax/dojo/src/dnd/HtmlDragAndDrop.js b/source/web/scripts/ajax/dojo/src/dnd/HtmlDragAndDrop.js
new file mode 100644
index 0000000000..a916532d99
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/dnd/HtmlDragAndDrop.js
@@ -0,0 +1,519 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.dnd.HtmlDragAndDrop");
+
+dojo.require("dojo.dnd.HtmlDragManager");
+dojo.require("dojo.dnd.DragAndDrop");
+
+dojo.require("dojo.html.*");
+dojo.require("dojo.html.display");
+dojo.require("dojo.html.util");
+dojo.require("dojo.html.selection");
+dojo.require("dojo.html.iframe");
+dojo.require("dojo.lang.extras");
+dojo.require("dojo.lfx.*");
+dojo.require("dojo.event.*");
+
+dojo.declare("dojo.dnd.HtmlDragSource", dojo.dnd.DragSource, {
+ dragClass: "", // CSS classname(s) applied to node when it is being dragged
+
+ onDragStart: function(){
+ var dragObj = new dojo.dnd.HtmlDragObject(this.dragObject, this.type);
+ if(this.dragClass){
+ dragObj.dragClass = this.dragClass;
+ }
+
+ if(this.constrainToContainer){
+ dragObj.constrainTo(this.constrainingContainer || this.domNode.parentNode);
+ }
+
+ return dragObj;
+ },
+
+ setDragHandle: function(node){
+ node = dojo.byId(node);
+ dojo.dnd.dragManager.unregisterDragSource(this);
+ this.domNode = node;
+ dojo.dnd.dragManager.registerDragSource(this);
+ },
+
+ setDragTarget: function(node){
+ this.dragObject = node;
+ },
+
+ constrainTo: function(container){
+ this.constrainToContainer = true;
+ if(container){
+ this.constrainingContainer = container;
+ }
+ },
+
+ /*
+ *
+ * see dojo.dnd.DragSource.onSelected
+ */
+ onSelected: function(){
+ for(var i=0; i this.constraints.maxX) { x = this.constraints.maxX; }
+ if (y > this.constraints.maxY) { y = this.constraints.maxY; }
+ }
+
+ this.setAbsolutePosition(x, y);
+
+ dojo.event.topic.publish('dragMove', { source: this } );
+ },
+
+ /**
+ * Set the position of the drag clone. (x,y) is relative to .
+ */
+ setAbsolutePosition: function(x, y){
+ // The drag clone is attached to document.body so this is trivial
+ if(!this.disableY) { this.dragClone.style.top = y + "px"; }
+ if(!this.disableX) { this.dragClone.style.left = x + "px"; }
+ },
+
+
+ /**
+ * If the drag operation returned a success we remove the clone of
+ * ourself from the original position. If the drag operation returned
+ * failure we slide back over to where we came from and end the operation
+ * with a little grace.
+ */
+ onDragEnd: function(e){
+ switch(e.dragStatus){
+
+ case "dropSuccess":
+ dojo.html.removeNode(this.dragClone);
+ this.dragClone = null;
+ break;
+
+ case "dropFailure": // slide back to the start
+ var startCoords = dojo.html.getAbsolutePosition(this.dragClone, true);
+ // offset the end so the effect can be seen
+ var endCoords = { left: this.dragStartPosition.x + 1,
+ top: this.dragStartPosition.y + 1};
+
+ // animate
+ var anim = dojo.lfx.slideTo(this.dragClone, endCoords, 300);
+ var dragObject = this;
+ dojo.event.connect(anim, "onEnd", function(e){
+ // pause for a second (not literally) and disappear
+ // dojo.lang.setTimeout(function() {
+ dojo.html.removeNode(dragObject.dragClone);
+ // Allow drag clone to be gc'ed
+ dragObject.dragClone = null;
+ // },
+ // 50);
+ });
+ anim.play();
+ break;
+ }
+
+ dojo.event.topic.publish('dragEnd', { source: this } );
+ },
+
+ constrainTo: function(container){
+ this.constrainToContainer=true;
+ if(container){
+ this.constrainingContainer = container;
+ }else{
+ this.constrainingContainer = this.domNode.parentNode;
+ }
+ }
+ },
+ function(node, type){
+ this.domNode = dojo.byId(node);
+ this.type = type;
+ this.constrainToContainer = false;
+ this.dragSource = null;
+ // this.register();
+ dojo.dnd.DragObject.prototype.register.call(this);
+ }
+);
+
+dojo.declare("dojo.dnd.HtmlDropTarget",
+ dojo.dnd.DropTarget,
+ {
+ vertical: false,
+ onDragOver: function(e){
+ if(!this.accepts(e.dragObjects)){ return false; }
+
+ // cache the positions of the child nodes
+ this.childBoxes = [];
+ for(var i = 0, child; i < this.domNode.childNodes.length; i++){
+ child = this.domNode.childNodes[i];
+ if(child.nodeType != dojo.html.ELEMENT_NODE){ continue; }
+ var pos = dojo.html.getAbsolutePosition(child, true);
+ var inner = dojo.html.getBorderBox(child);
+ this.childBoxes.push({top: pos.y, bottom: pos.y+inner.height,
+ left: pos.x, right: pos.x+inner.width, height: inner.height,
+ width: inner.width, node: child});
+ }
+
+ // TODO: use dummy node
+
+ return true;
+ },
+
+ _getNodeUnderMouse: function(e){
+ // find the child
+ for(var i = 0, child; i < this.childBoxes.length; i++){
+ with(this.childBoxes[i]){
+ if (e.pageX >= left && e.pageX <= right &&
+ e.pageY >= top && e.pageY <= bottom){ return i; }
+ }
+ }
+
+ return -1;
+ },
+
+ createDropIndicator: function(){
+ this.dropIndicator = document.createElement("div");
+ with(this.dropIndicator.style){
+ position = "absolute";
+ zIndex = 999;
+ if(this.vertical){
+ borderLeftWidth = "1px";
+ borderLeftColor = "black";
+ borderLeftStyle = "solid";
+ height = dojo.html.getBorderBox(this.domNode).height + "px";
+ top = dojo.html.getAbsolutePosition(this.domNode, true).y + "px";
+ }else{
+ borderTopWidth = "1px";
+ borderTopColor = "black";
+ borderTopStyle = "solid";
+ width = dojo.html.getBorderBox(this.domNode).width + "px";
+ left = dojo.html.getAbsolutePosition(this.domNode, true).x + "px";
+ }
+ }
+ },
+
+ onDragMove: function(e, dragObjects){
+ var i = this._getNodeUnderMouse(e);
+
+ if(!this.dropIndicator){
+ this.createDropIndicator();
+ }
+
+ var gravity = this.vertical ? dojo.html.gravity.WEST : dojo.html.gravity.NORTH;
+ var hide = false;
+ if(i < 0){
+ if(this.childBoxes.length){
+ var before = (dojo.html.gravity(this.childBoxes[0].node, e) & gravity);
+ if(before){ hide = true; }
+ }else{
+ var before = true;
+ }
+ }else{
+ var child = this.childBoxes[i];
+ var before = (dojo.html.gravity(child.node, e) & gravity);
+ if(child.node === dragObjects[0].dragSource.domNode){
+ hide = true;
+ }else{
+ var currentPosChild = before ?
+ (i>0?this.childBoxes[i-1]:child) :
+ (i
+ * (draggable selection)
+ * (dragObject generation)
+ * mouse-move ->
+ * (draggable movement)
+ * (droppable detection)
+ * (inform droppable)
+ * (inform dragObject)
+ * mouse-up
+ * (inform/destroy dragObject)
+ * (inform draggable)
+ * (inform droppable)
+ * 2.) mouse-down -> mouse-down
+ * (click-hold context menu)
+ * 3.) mouse-click ->
+ * (draggable selection)
+ * shift-mouse-click ->
+ * (augment draggable selection)
+ * mouse-down ->
+ * (dragObject generation)
+ * mouse-move ->
+ * (draggable movement)
+ * (droppable detection)
+ * (inform droppable)
+ * (inform dragObject)
+ * mouse-up
+ * (inform draggable)
+ * (inform droppable)
+ * 4.) mouse-up
+ * (clobber draggable selection)
+ */
+ disabled: false, // to kill all dragging!
+ nestedTargets: false,
+ mouseDownTimer: null, // used for click-hold operations
+ dsCounter: 0,
+ dsPrefix: "dojoDragSource",
+
+ // dimension calculation cache for use durring drag
+ dropTargetDimensions: [],
+
+ currentDropTarget: null,
+ // currentDropTargetPoints: null,
+ previousDropTarget: null,
+ _dragTriggered: false,
+
+ selectedSources: [],
+ dragObjects: [],
+ dragSources: [],
+
+ // mouse position properties
+ currentX: null,
+ currentY: null,
+ lastX: null,
+ lastY: null,
+ mouseDownX: null,
+ mouseDownY: null,
+ threshold: 7,
+
+ dropAcceptable: false,
+
+ cancelEvent: function(e){ e.stopPropagation(); e.preventDefault();},
+
+ // method over-rides
+ registerDragSource: function(ds){
+ //dojo.profile.start("register DragSource");
+
+ if(ds["domNode"]){
+ // FIXME: dragSource objects SHOULD have some sort of property that
+ // references their DOM node, we shouldn't just be passing nodes and
+ // expecting it to work.
+ //dojo.profile.start("register DragSource 1");
+ var dp = this.dsPrefix;
+ var dpIdx = dp+"Idx_"+(this.dsCounter++);
+ ds.dragSourceId = dpIdx;
+ this.dragSources[dpIdx] = ds;
+ ds.domNode.setAttribute(dp, dpIdx);
+ //dojo.profile.end("register DragSource 1");
+
+ //dojo.profile.start("register DragSource 2");
+
+ // so we can drag links
+ if(dojo.render.html.ie){
+ //dojo.profile.start("register DragSource IE");
+
+ dojo.event.browser.addListener(ds.domNode, "ondragstart", this.cancelEvent);
+ // terribly slow
+ //dojo.event.connect(ds.domNode, "ondragstart", this.cancelEvent);
+ //dojo.profile.end("register DragSource IE");
+
+ }
+ //dojo.profile.end("register DragSource 2");
+
+ }
+ //dojo.profile.end("register DragSource");
+ },
+
+ unregisterDragSource: function(ds){
+ if (ds["domNode"]){
+ var dp = this.dsPrefix;
+ var dpIdx = ds.dragSourceId;
+ delete ds.dragSourceId;
+ delete this.dragSources[dpIdx];
+ ds.domNode.setAttribute(dp, null);
+ if(dojo.render.html.ie){
+ dojo.event.browser.removeListener(ds.domNode, "ondragstart", this.cancelEvent);
+ }
+ }
+ },
+
+ registerDropTarget: function(dt){
+ this.dropTargets.push(dt);
+ },
+
+ unregisterDropTarget: function(dt){
+ var index = dojo.lang.find(this.dropTargets, dt, true);
+ if (index>=0) {
+ this.dropTargets.splice(index, 1);
+ }
+ },
+
+ /**
+ * Get the DOM element that is meant to drag.
+ * Loop through the parent nodes of the event target until
+ * the element is found that was created as a DragSource and
+ * return it.
+ *
+ * @param event object The event for which to get the drag source.
+ */
+ getDragSource: function(e){
+ var tn = e.target;
+ if(tn === dojo.body()){ return; }
+ var ta = dojo.html.getAttribute(tn, this.dsPrefix);
+ while((!ta)&&(tn)){
+ tn = tn.parentNode;
+ if((!tn)||(tn === dojo.body())){ return; }
+ ta = dojo.html.getAttribute(tn, this.dsPrefix);
+ }
+ return this.dragSources[ta];
+ },
+
+ onKeyDown: function(e){
+ },
+
+ onMouseDown: function(e){
+ if(this.disabled) { return; }
+
+ // only begin on left click
+ if(dojo.render.html.ie) {
+ if(e.button != 1) { return; }
+ } else if(e.which != 1) {
+ return;
+ }
+
+ var target = e.target.nodeType == dojo.html.TEXT_NODE ?
+ e.target.parentNode : e.target;
+
+ // do not start drag involvement if the user is interacting with
+ // a form element.
+ if(dojo.html.isTag(target, "button", "textarea", "input", "select", "option")) {
+ return;
+ }
+
+ // find a selection object, if one is a parent of the source node
+ var ds = this.getDragSource(e);
+
+ // this line is important. if we aren't selecting anything then
+ // we need to return now, so preventDefault() isn't called, and thus
+ // the event is propogated to other handling code
+ if(!ds){ return; }
+
+ if(!dojo.lang.inArray(this.selectedSources, ds)){
+ this.selectedSources.push(ds);
+ ds.onSelected();
+ }
+
+ this.mouseDownX = e.pageX;
+ this.mouseDownY = e.pageY;
+
+ // Must stop the mouse down from being propogated, or otherwise can't
+ // drag links in firefox.
+ // WARNING: preventing the default action on all mousedown events
+ // prevents user interaction with the contents.
+ e.preventDefault();
+
+ dojo.event.connect(document, "onmousemove", this, "onMouseMove");
+ },
+
+ onMouseUp: function(e, cancel){
+ // if we aren't dragging then ignore the mouse-up
+ // (in particular, don't call preventDefault(), because other
+ // code may need to process this event)
+ if(this.selectedSources.length==0){
+ return;
+ }
+
+ this.mouseDownX = null;
+ this.mouseDownY = null;
+ this._dragTriggered = false;
+ // e.preventDefault();
+ e.dragSource = this.dragSource;
+ // let ctrl be used for multiselect or another action
+ // if I use same key to trigger treeV3 node selection and here,
+ // I have bugs with drag'n'drop. why ?? no idea..
+ if((!e.shiftKey)&&(!e.ctrlKey)){
+ //if(!e.shiftKey){
+ if(this.currentDropTarget) {
+ this.currentDropTarget.onDropStart();
+ }
+ dojo.lang.forEach(this.dragObjects, function(tempDragObj){
+ var ret = null;
+ if(!tempDragObj){ return; }
+ if(this.currentDropTarget) {
+ e.dragObject = tempDragObj;
+
+ // NOTE: we can't get anything but the current drop target
+ // here since the drag shadow blocks mouse-over events.
+ // This is probelematic for dropping "in" something
+ var ce = this.currentDropTarget.domNode.childNodes;
+ if(ce.length > 0){
+ e.dropTarget = ce[0];
+ while(e.dropTarget == tempDragObj.domNode){
+ e.dropTarget = e.dropTarget.nextSibling;
+ }
+ }else{
+ e.dropTarget = this.currentDropTarget.domNode;
+ }
+ if(this.dropAcceptable){
+ ret = this.currentDropTarget.onDrop(e);
+ }else{
+ this.currentDropTarget.onDragOut(e);
+ }
+ }
+
+ e.dragStatus = this.dropAcceptable && ret ? "dropSuccess" : "dropFailure";
+ // decouple the calls for onDragEnd, so they don't block the execution here
+ // ie. if the onDragEnd would call an alert, the execution here is blocked until the
+ // user has confirmed the alert box and then the rest of the dnd code is executed
+ // while the mouse doesnt "hold" the dragged object anymore ... and so on
+ dojo.lang.delayThese([
+ function() {
+ // in FF1.5 this throws an exception, see
+ // http://dojotoolkit.org/pipermail/dojo-interest/2006-April/006751.html
+ try{
+ tempDragObj.dragSource.onDragEnd(e)
+ } catch(err) {
+ // since the problem seems passing e, we just copy all
+ // properties and try the copy ...
+ var ecopy = {};
+ for (var i in e) {
+ if (i=="type") { // the type property contains the exception, no idea why...
+ ecopy.type = "mouseup";
+ continue;
+ }
+ ecopy[i] = e[i];
+ }
+ tempDragObj.dragSource.onDragEnd(ecopy);
+ }
+ }
+ , function() {tempDragObj.onDragEnd(e)}]);
+ }, this);
+
+ this.selectedSources = [];
+ this.dragObjects = [];
+ this.dragSource = null;
+ if(this.currentDropTarget) {
+ this.currentDropTarget.onDropEnd();
+ }
+ } else {
+ //dojo.debug("special click");
+ }
+
+ dojo.event.disconnect(document, "onmousemove", this, "onMouseMove");
+ this.currentDropTarget = null;
+ },
+
+ onScroll: function(){
+ //dojo.profile.start("DNDManager updateoffset");
+ for(var i = 0; i < this.dragObjects.length; i++) {
+ if(this.dragObjects[i].updateDragOffset) {
+ this.dragObjects[i].updateDragOffset();
+ }
+ }
+ //dojo.profile.end("DNDManager updateoffset");
+
+ // TODO: do not recalculate, only adjust coordinates
+ if (this.dragObjects.length) {
+ this.cacheTargetLocations();
+ }
+ },
+
+ _dragStartDistance: function(x, y){
+ if((!this.mouseDownX)||(!this.mouseDownX)){
+ return;
+ }
+ var dx = Math.abs(x-this.mouseDownX);
+ var dx2 = dx*dx;
+ var dy = Math.abs(y-this.mouseDownY);
+ var dy2 = dy*dy;
+ return parseInt(Math.sqrt(dx2+dy2), 10);
+ },
+
+ cacheTargetLocations: function(){
+ dojo.profile.start("cacheTargetLocations");
+
+ this.dropTargetDimensions = [];
+ dojo.lang.forEach(this.dropTargets, function(tempTarget){
+ var tn = tempTarget.domNode;
+ //only cache dropTarget which can accept current dragSource
+ if(!tn || !tempTarget.accepts([this.dragSource])){ return; }
+ var abs = dojo.html.getAbsolutePosition(tn, true);
+ var bb = dojo.html.getBorderBox(tn);
+ this.dropTargetDimensions.push([
+ [abs.x, abs.y], // upper-left
+ // lower-right
+ [ abs.x+bb.width, abs.y+bb.height ],
+ tempTarget
+ ]);
+ //dojo.debug("Cached for "+tempTarget)
+ }, this);
+
+ dojo.profile.end("cacheTargetLocations");
+
+ //dojo.debug("Cache locations")
+ },
+
+ onMouseMove: function(e){
+ if((dojo.render.html.ie)&&(e.button != 1)){
+ // Oooops - mouse up occurred - e.g. when mouse was not over the
+ // window. I don't think we can detect this for FF - but at least
+ // we can be nice in IE.
+ this.currentDropTarget = null;
+ this.onMouseUp(e, true);
+ return;
+ }
+
+ // if we've got some sources, but no drag objects, we need to send
+ // onDragStart to all the right parties and get things lined up for
+ // drop target detection
+
+ if( (this.selectedSources.length)&&
+ (!this.dragObjects.length) ){
+ var dx;
+ var dy;
+ if(!this._dragTriggered){
+ this._dragTriggered = (this._dragStartDistance(e.pageX, e.pageY) > this.threshold);
+ if(!this._dragTriggered){ return; }
+ dx = e.pageX - this.mouseDownX;
+ dy = e.pageY - this.mouseDownY;
+ }
+
+ // the first element is always our dragSource, if there are multiple
+ // selectedSources (elements that move along) then the first one is the master
+ // and for it the events will be fired etc.
+ this.dragSource = this.selectedSources[0];
+
+ dojo.lang.forEach(this.selectedSources, function(tempSource){
+ if(!tempSource){ return; }
+ var tdo = tempSource.onDragStart(e);
+ if(tdo){
+ tdo.onDragStart(e);
+
+ // "bump" the drag object to account for the drag threshold
+ tdo.dragOffset.y += dy;
+ tdo.dragOffset.x += dx;
+ tdo.dragSource = tempSource;
+
+ this.dragObjects.push(tdo);
+ }
+ }, this);
+
+ /* clean previous drop target in dragStart */
+ this.previousDropTarget = null;
+
+ this.cacheTargetLocations();
+ }
+
+ // FIXME: we need to add dragSources and dragObjects to e
+ dojo.lang.forEach(this.dragObjects, function(dragObj){
+ if(dragObj){ dragObj.onDragMove(e); }
+ });
+
+ // if we have a current drop target, check to see if we're outside of
+ // it. If so, do all the actions that need doing.
+ if(this.currentDropTarget){
+ //dojo.debug(dojo.html.hasParent(this.currentDropTarget.domNode))
+ var c = dojo.html.toCoordinateObject(this.currentDropTarget.domNode, true);
+ // var dtp = this.currentDropTargetPoints;
+ var dtp = [
+ [c.x,c.y], [c.x+c.width, c.y+c.height]
+ ];
+ }
+
+ if((!this.nestedTargets)&&(dtp)&&(this.isInsideBox(e, dtp))){
+ if(this.dropAcceptable){
+ this.currentDropTarget.onDragMove(e, this.dragObjects);
+ }
+ }else{
+ // FIXME: need to fix the event object!
+ // see if we can find a better drop target
+ var bestBox = this.findBestTarget(e);
+
+ if(bestBox.target === null){
+ if(this.currentDropTarget){
+ this.currentDropTarget.onDragOut(e);
+ this.previousDropTarget = this.currentDropTarget;
+ this.currentDropTarget = null;
+ // this.currentDropTargetPoints = null;
+ }
+ this.dropAcceptable = false;
+ return;
+ }
+
+ if(this.currentDropTarget !== bestBox.target){
+ if(this.currentDropTarget){
+ this.previousDropTarget = this.currentDropTarget;
+ this.currentDropTarget.onDragOut(e);
+ }
+ this.currentDropTarget = bestBox.target;
+ // this.currentDropTargetPoints = bestBox.points;
+ e.dragObjects = this.dragObjects;
+ this.dropAcceptable = this.currentDropTarget.onDragOver(e);
+
+ }else{
+ if(this.dropAcceptable){
+ this.currentDropTarget.onDragMove(e, this.dragObjects);
+ }
+ }
+ }
+ },
+
+ findBestTarget: function(e) {
+ var _this = this;
+ var bestBox = new Object();
+ bestBox.target = null;
+ bestBox.points = null;
+ dojo.lang.every(this.dropTargetDimensions, function(tmpDA) {
+ if(!_this.isInsideBox(e, tmpDA)){
+ return true;
+ }
+
+ bestBox.target = tmpDA[2];
+ bestBox.points = tmpDA;
+ // continue iterating only if _this.nestedTargets == true
+ return Boolean(_this.nestedTargets);
+ });
+
+ return bestBox;
+ },
+
+ isInsideBox: function(e, coords){
+ if( (e.pageX > coords[0][0])&&
+ (e.pageX < coords[1][0])&&
+ (e.pageY > coords[0][1])&&
+ (e.pageY < coords[1][1]) ){
+ return true;
+ }
+ return false;
+ },
+
+ onMouseOver: function(e){
+ },
+
+ onMouseOut: function(e){
+ }
+});
+
+dojo.dnd.dragManager = new dojo.dnd.HtmlDragManager();
+
+// global namespace protection closure
+(function(){
+ var d = document;
+ var dm = dojo.dnd.dragManager;
+ //TODO: when focus manager is ready, dragManager should be rewritten to use it
+ // set up event handlers on the document (or no?)
+ dojo.event.connect(d, "onkeydown", dm, "onKeyDown");
+ dojo.event.connect(d, "onmouseover", dm, "onMouseOver");
+ dojo.event.connect(d, "onmouseout", dm, "onMouseOut");
+ dojo.event.connect(d, "onmousedown", dm, "onMouseDown");
+ dojo.event.connect(d, "onmouseup", dm, "onMouseUp");
+ // TODO: process scrolling of elements, not only window (focus manager would
+ // probably come to rescue here as well)
+ dojo.event.connect(window, "onscroll", dm, "onScroll");
+})();
diff --git a/source/web/scripts/ajax/dojo/src/dnd/HtmlDragMove.js b/source/web/scripts/ajax/dojo/src/dnd/HtmlDragMove.js
new file mode 100644
index 0000000000..f1529f868d
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/dnd/HtmlDragMove.js
@@ -0,0 +1,89 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.dnd.HtmlDragMove");
+dojo.require("dojo.dnd.*");
+
+dojo.declare("dojo.dnd.HtmlDragMoveSource", dojo.dnd.HtmlDragSource, {
+ onDragStart: function(){
+ var dragObj = new dojo.dnd.HtmlDragMoveObject(this.dragObject, this.type);
+ if (this.constrainToContainer) {
+ dragObj.constrainTo(this.constrainingContainer);
+ }
+ return dragObj;
+ },
+ /*
+ * see dojo.dnd.HtmlDragSource.onSelected
+ */
+ onSelected: function() {
+ for (var i=0; i it was allowed before, no accept check is needed
+ if (position=="onto" ||
+ (!this.isAdjacentNode(sourceTreeNode, position)
+ && this.controller.canMove(sourceTreeNode, this.treeNode.parent)
+ )
+ ) {
+ return position;
+ } else {
+ return false;
+ }
+
+ },
+
+ onDragOut: function(e) {
+ this.clearAutoExpandTimer();
+
+ this.hideIndicator();
+ },
+
+
+ clearAutoExpandTimer: function() {
+ if (this.autoExpandTimer) {
+ clearTimeout(this.autoExpandTimer);
+ this.autoExpandTimer = null;
+ }
+ },
+
+
+
+ onDragMove: function(e, dragObjects){
+
+ var sourceTreeNode = dragObjects[0].treeNode;
+
+ var position = this.getAcceptPosition(e, sourceTreeNode);
+
+ if (position) {
+ this.showIndicator(position);
+ }
+
+ },
+
+ isAdjacentNode: function(sourceNode, position) {
+
+ if (sourceNode === this.treeNode) return true;
+ if (sourceNode.getNextSibling() === this.treeNode && position=="before") return true;
+ if (sourceNode.getPreviousSibling() === this.treeNode && position=="after") return true;
+
+ return false;
+ },
+
+
+ /* get DNDMode and see which position e fits */
+ getPosition: function(e, DNDMode) {
+ var node = dojo.byId(this.treeNode.labelNode);
+ var mousey = e.pageY || e.clientY + dojo.body().scrollTop;
+ var nodey = dojo.html.getAbsolutePosition(node).y;
+ var height = dojo.html.getBorderBox(node).height;
+
+ var relY = mousey - nodey;
+ var p = relY / height;
+
+ var position = ""; // "" <=> forbidden
+ if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO
+ && DNDMode & dojo.widget.Tree.prototype.DNDModes.BETWEEN) {
+ if (p<=0.3) {
+ position = "before";
+ } else if (p<=0.7) {
+ position = "onto";
+ } else {
+ position = "after";
+ }
+ } else if (DNDMode & dojo.widget.Tree.prototype.DNDModes.BETWEEN) {
+ if (p<=0.5) {
+ position = "before";
+ } else {
+ position = "after";
+ }
+ }
+ else if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO) {
+ position = "onto";
+ }
+
+
+ return position;
+ },
+
+
+
+ getTargetParentIndex: function(sourceTreeNode, position) {
+
+ var index = position == "before" ? this.treeNode.getParentIndex() : this.treeNode.getParentIndex()+1;
+ if (this.treeNode.parent === sourceTreeNode.parent
+ && this.treeNode.getParentIndex() > sourceTreeNode.getParentIndex()) {
+ index--; // dragging a node is different for simple move bacause of before-after issues
+ }
+
+ return index;
+ },
+
+
+ onDrop: function(e){
+ // onDragOut will clean position
+
+
+ var position = this.position;
+
+//dojo.debug(position);
+
+ this.onDragOut(e);
+
+ var sourceTreeNode = e.dragObject.treeNode;
+
+ if (!dojo.lang.isObject(sourceTreeNode)) {
+ dojo.raise("TreeNode not found in dragObject")
+ }
+
+ if (position == "onto") {
+ return this.controller.move(sourceTreeNode, this.treeNode, 0);
+ } else {
+ var index = this.getTargetParentIndex(sourceTreeNode, position);
+ return this.controller.move(sourceTreeNode, this.treeNode.parent, index);
+ }
+
+ //dojo.debug('drop2');
+
+
+
+ }
+
+
+});
+
+
+
+dojo.dnd.TreeDNDController = function(treeController) {
+
+ // I use this controller to perform actions
+ this.treeController = treeController;
+
+ this.dragSources = {};
+
+ this.dropTargets = {};
+
+}
+
+dojo.lang.extend(dojo.dnd.TreeDNDController, {
+
+
+ listenTree: function(tree) {
+ //dojo.debug("Listen tree "+tree);
+ dojo.event.topic.subscribe(tree.eventNames.createDOMNode, this, "onCreateDOMNode");
+ dojo.event.topic.subscribe(tree.eventNames.moveFrom, this, "onMoveFrom");
+ dojo.event.topic.subscribe(tree.eventNames.moveTo, this, "onMoveTo");
+ dojo.event.topic.subscribe(tree.eventNames.addChild, this, "onAddChild");
+ dojo.event.topic.subscribe(tree.eventNames.removeNode, this, "onRemoveNode");
+ dojo.event.topic.subscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy");
+ },
+
+
+ unlistenTree: function(tree) {
+ //dojo.debug("Listen tree "+tree);
+ dojo.event.topic.unsubscribe(tree.eventNames.createDOMNode, this, "onCreateDOMNode");
+ dojo.event.topic.unsubscribe(tree.eventNames.moveFrom, this, "onMoveFrom");
+ dojo.event.topic.unsubscribe(tree.eventNames.moveTo, this, "onMoveTo");
+ dojo.event.topic.unsubscribe(tree.eventNames.addChild, this, "onAddChild");
+ dojo.event.topic.unsubscribe(tree.eventNames.removeNode, this, "onRemoveNode");
+ dojo.event.topic.unsubscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy");
+ },
+
+ onTreeDestroy: function(message) {
+ this.unlistenTree(message.source);
+ // I'm not widget so don't use destroy() call and dieWithTree
+ },
+
+ onCreateDOMNode: function(message) {
+ this.registerDNDNode(message.source);
+ },
+
+ onAddChild: function(message) {
+ this.registerDNDNode(message.child);
+ },
+
+ onMoveFrom: function(message) {
+ var _this = this;
+ dojo.lang.forEach(
+ message.child.getDescendants(),
+ function(node) { _this.unregisterDNDNode(node); }
+ );
+ },
+
+ onMoveTo: function(message) {
+ var _this = this;
+ dojo.lang.forEach(
+ message.child.getDescendants(),
+ function(node) { _this.registerDNDNode(node); }
+ );
+ },
+
+ /**
+ * Controller(node model) creates DNDNodes because it passes itself to node for synchroneous drops processing
+ * I can't process DnD with events cause an event can't return result success/false
+ */
+ registerDNDNode: function(node) {
+ if (!node.tree.DNDMode) return;
+
+//dojo.debug("registerDNDNode "+node);
+
+ /* I drag label, not domNode, because large domNodes are very slow to copy and large to drag */
+
+ var source = null;
+ var target = null;
+
+ if (!node.actionIsDisabled(node.actions.MOVE)) {
+ //dojo.debug("reg source")
+ var source = new dojo.dnd.TreeDragSource(node.labelNode, this, node.tree.widgetId, node);
+ this.dragSources[node.widgetId] = source;
+ }
+
+ var target = new dojo.dnd.TreeDropTarget(node.labelNode, this.treeController, node.tree.DNDAcceptTypes, node);
+
+ this.dropTargets[node.widgetId] = target;
+
+ },
+
+
+ unregisterDNDNode: function(node) {
+
+ if (this.dragSources[node.widgetId]) {
+ dojo.dnd.dragManager.unregisterDragSource(this.dragSources[node.widgetId]);
+ delete this.dragSources[node.widgetId];
+ }
+
+ if (this.dropTargets[node.widgetId]) {
+ dojo.dnd.dragManager.unregisterDropTarget(this.dropTargets[node.widgetId]);
+ delete this.dropTargets[node.widgetId];
+ }
+ }
+
+
+
+
+
+});
diff --git a/source/web/scripts/ajax/dojo/src/dnd/TreeDragAndDropV3.js b/source/web/scripts/ajax/dojo/src/dnd/TreeDragAndDropV3.js
new file mode 100644
index 0000000000..d2e4a1dcde
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/dnd/TreeDragAndDropV3.js
@@ -0,0 +1,403 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+/**
+ * TreeDrag* specialized on managing subtree drags
+ * It selects nodes and visualises what's going on,
+ * but delegates real actions upon tree to the controller
+ *
+ * This code is considered a part of controller
+*/
+
+dojo.provide("dojo.dnd.TreeDragAndDropV3");
+
+dojo.require("dojo.dnd.HtmlDragAndDrop");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.lang.extras");
+dojo.require("dojo.Deferred");
+dojo.require("dojo.html.layout");
+
+// FIXME: if controller can't move then skip node on move start
+dojo.dnd.TreeDragSourceV3 = function(node, syncController, type, treeNode){
+ //dojo.profile.start("TreeDragSourceV3 "+treeNode);
+ this.controller = syncController;
+ this.treeNode = treeNode;
+
+ dojo.dnd.HtmlDragSource.call(this, node, type);
+ //dojo.profile.end("TreeDragSourceV3 "+treeNode);
+}
+
+dojo.inherits(dojo.dnd.TreeDragSourceV3, dojo.dnd.HtmlDragSource);
+
+
+// .......................................
+
+dojo.dnd.TreeDropTargetV3 = function(domNode, controller, type, treeNode){
+
+ this.treeNode = treeNode;
+ this.controller = controller; // I will sync-ly process drops
+
+ dojo.dnd.HtmlDropTarget.call(this, domNode, type);
+}
+
+dojo.inherits(dojo.dnd.TreeDropTargetV3, dojo.dnd.HtmlDropTarget);
+
+dojo.lang.extend(dojo.dnd.TreeDropTargetV3, {
+
+ autoExpandDelay: 1500,
+ autoExpandTimer: null,
+
+
+ position: null,
+
+ indicatorStyle: "2px black groove",
+
+ showIndicator: function(position) {
+
+ // do not change style too often, cause of blinking possible
+ if (this.position == position) {
+ return;
+ }
+
+ //dojo.debug("set position for "+this.treeNode)
+
+ this.hideIndicator();
+
+ this.position = position;
+
+ var node = this.treeNode;
+
+
+ node.contentNode.style.width = dojo.html.getBorderBox(node.labelNode).width + "px";
+
+ if (position == "onto") {
+ node.contentNode.style.border = this.indicatorStyle;
+ } else {
+ // FIXME: bottom-top or highlight should cover ONLY top/bottom or div itself,
+ // not span whole line (try Dnd)
+ // FAILURE: Can't put span inside div: multiline bottom-top will span multiple lines
+ if (position == "before") {
+ node.contentNode.style.borderTop = this.indicatorStyle;
+ } else if (position == "after") {
+ node.contentNode.style.borderBottom = this.indicatorStyle;
+ }
+ }
+ },
+
+ hideIndicator: function() {
+ this.treeNode.contentNode.style.borderBottom = "";
+ this.treeNode.contentNode.style.borderTop = "";
+ this.treeNode.contentNode.style.border = "";
+ this.treeNode.contentNode.style.width=""
+ this.position = null;
+ },
+
+
+
+ // is the target possibly ok ?
+ // This function is run on dragOver, but drop possibility is also determined by position over node
+ // that's why acceptsWithPosition is called
+ // doesnt take index into account ( can change while moving mouse w/o changing target )
+ /**
+ * Coarse (tree-level) access check.
+ * We can't determine real accepts status w/o position
+ */
+ onDragOver: function(e){
+ //dojo.debug("onDragOver for "+e);
+
+ var accepts = dojo.dnd.HtmlDropTarget.prototype.onDragOver.apply(this, arguments);
+
+ //dojo.debug("TreeDropTarget.onDragOver accepts:"+accepts)
+
+ if (accepts && this.treeNode.isFolder && !this.treeNode.isExpanded) {
+ this.setAutoExpandTimer();
+ }
+
+ if (accepts) {
+ this.cacheNodeCoords();
+ }
+
+
+ return accepts;
+ },
+
+ /* Parent.onDragOver calls this function to get accepts status */
+ accepts: function(dragObjects) {
+
+ var accepts = dojo.dnd.HtmlDropTarget.prototype.accepts.apply(this, arguments);
+
+ //dojo.debug("accepts "+accepts);
+
+ if (!accepts) return false;
+
+ for(var i=0; i it was allowed before, no accept check is needed
+ if (position=="onto") {
+ return position;
+ }
+
+ for(var i=0; i forbidden
+ if (DndMode & dojo.widget.TreeV3.prototype.DndModes.ONTO
+ && DndMode & dojo.widget.TreeV3.prototype.DndModes.BETWEEN) {
+ //dojo.debug("BOTH");
+ if (p<=0.33) {
+ position = "before";
+ // if children are expanded then I ignore understrike, cause it is confusing with firstChild
+ // but for last nodes I put understrike there
+ } else if (p<=0.66 || this.treeNode.isExpanded && this.treeNode.children.length && !this.treeNode.isLastChild()) {
+ position = "onto";
+ } else {
+ position = "after";
+ }
+ } else if (DndMode & dojo.widget.TreeV3.prototype.DndModes.BETWEEN) {
+ //dojo.debug("BETWEEN");
+ if (p<=0.5 || this.treeNode.isExpanded && this.treeNode.children.length && !this.treeNode.isLastChild()) {
+ position = "before";
+ } else {
+ position = "after";
+ }
+ }
+ else if (DndMode & dojo.widget.TreeV3.prototype.DndModes.ONTO) {
+ //dojo.debug("ONTO");
+ position = "onto";
+ }
+
+ //dojo.debug(position);
+
+ return position;
+ },
+
+
+
+ getTargetParentIndex: function(source, position) {
+
+ var index = position == "before" ? this.treeNode.getParentIndex() : this.treeNode.getParentIndex()+1;
+ if (source.treeNode
+ && this.treeNode.parent === source.treeNode.parent
+ && this.treeNode.getParentIndex() > source.treeNode.getParentIndex()) {
+ index--; // dragging a node is different for simple move bacause of before-after issues
+ }
+
+ return index;
+ },
+
+
+ onDrop: function(e) {
+ // onDropEnd will clean position
+
+
+ var position = this.position;
+
+//dojo.debug(position);
+ var source = e.dragObject.dragSource;
+
+ //dojo.debug("onDrop "+source.treeNode+" " + position + " "+this.treeNode);
+
+
+ var targetParent, targetIndex;
+ if (position == "onto") {
+ targetParent = this.treeNode;
+ targetIndex = 0;
+ } else {
+ targetIndex = this.getTargetParentIndex(source, position);
+ targetParent = this.treeNode.parent;
+ }
+
+ //dojo.profile.start("onDrop "+sourceTreeNode);
+ var r = this.getDropHandler(e, source, targetParent, targetIndex)();
+
+ //dojo.profile.end("onDrop "+sourceTreeNode);
+
+ return r;
+
+ },
+
+ /**
+ * determine, which action I should perform with nodes
+ * e.g move, clone..
+ */
+ getDropHandler: function(e, source, targetParent, targetIndex) {
+ var handler;
+ var _this = this;
+ handler = function () {
+ var result;
+
+ //dojo.debug("Move "+source.treeNode+" to parent "+targetParent+":"+targetIndex);
+ if (source.treeNode) {
+ result = _this.controller.move(source.treeNode, targetParent, targetIndex, true);
+ //dojo.debug("moved "+result);
+ } else {
+ if (dojo.lang.isFunction(source.onDrop)) {
+ source.onDrop(targetParent, targetIndex);
+ }
+
+ var treeNode = source.getTreeNode();
+ if (treeNode) {
+ result = _this.controller.createChild(targetParent, targetIndex, treeNode, true);
+ } else {
+ result = true;
+ }
+ }
+
+ if (result instanceof dojo.Deferred) {
+ // this Deferred is always sync
+ var isSuccess = result.fired == 0;
+ if (!isSuccess) {
+ _this.handleDropError(source, targetParent, targetIndex, result);
+ }
+
+ return isSuccess;
+
+ } else {
+ return result;
+ }
+ }
+
+ return handler;
+ },
+
+
+ handleDropError: function(source, parent, index, result) {
+ dojo.debug("TreeDropTargetV3.handleDropError: DND error occured");
+ dojo.debugShallow(result);
+ }
+
+
+});
+
diff --git a/source/web/scripts/ajax/dojo/src/dnd/__package__.js b/source/web/scripts/ajax/dojo/src/dnd/__package__.js
new file mode 100644
index 0000000000..0a93fd2bb1
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/dnd/__package__.js
@@ -0,0 +1,16 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.kwCompoundRequire({
+ common: ["dojo.dnd.DragAndDrop"],
+ browser: ["dojo.dnd.HtmlDragAndDrop"],
+ dashboard: ["dojo.dnd.HtmlDragAndDrop"]
+});
+dojo.provide("dojo.dnd.*");
diff --git a/source/web/scripts/ajax/dojo/src/docs.js b/source/web/scripts/ajax/dojo/src/docs.js
new file mode 100644
index 0000000000..ec7657cf4f
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/docs.js
@@ -0,0 +1,671 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.docs");
+dojo.require("dojo.io.*");
+dojo.require("dojo.event.topic");
+dojo.require("dojo.rpc.JotService");
+dojo.require("dojo.dom");
+dojo.require("dojo.uri.Uri");
+dojo.require("dojo.Deferred");
+dojo.require("dojo.DeferredList");
+
+/*
+ * TODO:
+ *
+ * Package summary needs to compensate for "is"
+ * Handle host environments
+ * Deal with dojo.widget weirdness
+ * Parse parameters
+ * Limit function parameters to only the valid ones (Involves packing parameters onto meta during rewriting)
+ *
+ */
+
+dojo.docs = new function() {
+ this._url = dojo.uri.dojoUri("docscripts");
+ this._rpc = new dojo.rpc.JotService;
+ this._rpc.serviceUrl = dojo.uri.dojoUri("docscripts/jsonrpc.php");
+};
+dojo.lang.mixin(dojo.docs, {
+ _count: 0,
+ _callbacks: {function_names: []},
+ _cache: {}, // Saves the JSON objects in cache
+ require: function(/*String*/ require, /*bool*/ sync) {
+ dojo.debug("require(): " + require);
+ var parts = require.split("/");
+
+ var size = parts.length;
+ var deferred = new dojo.Deferred;
+ var args = {
+ mimetype: "text/json",
+ load: function(type, data){
+ dojo.debug("require(): loaded for " + require);
+
+ if(parts[0] != "function_names") {
+ for(var i = 0, part; part = parts[i]; i++){
+ data = data[part];
+ }
+ }
+ deferred.callback(data);
+ },
+ error: function(){
+ deferred.errback();
+ }
+ };
+
+ if(location.protocol == "file:"){
+ if(size){
+ if(parts[parts.length - 1] == "documentation"){
+ parts[parts.length - 1] = "meta";
+ }
+
+ if(parts[0] == "function_names"){
+ args.url = [this._url, "local_json", "function_names"].join("/");
+ }else{
+ var dirs = parts[0].split(".");
+ args.url = [this._url, "local_json", dirs[0]].join("/");
+ if(dirs.length > 1){
+ args.url = [args.url, dirs[1]].join(".");
+ }
+ }
+ }
+ }
+
+ dojo.io.bind(args);
+ return deferred;
+ },
+ getFunctionNames: function(){
+ return this.require("function_names"); // dojo.Deferred
+ },
+ unFormat: function(/*String*/ string){
+ var fString = string;
+ if(string.charAt(string.length - 1) == "_"){
+ fString = [string.substring(0, string.length - 1), "*"].join("");
+ }
+ return fString;
+ },
+ getMeta: function(/*String*/ pkg, /*String*/ name, /*Function*/ callback, /*String?*/ id){
+ // summary: Gets information about a function in regards to its meta data
+ if(typeof name == "function"){
+ // pId: a
+ // pkg: ignore
+ id = callback;
+ callback = name;
+ name = pkg;
+ pkg = null;
+ dojo.debug("getMeta(" + name + ")");
+ }else{
+ dojo.debug("getMeta(" + pkg + "/" + name + ")");
+ }
+
+ if(!id){
+ id = "_";
+ }
+ },
+ _withPkg: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input, /*String*/ newType){
+ dojo.debug("_withPkg(" + evt.name + ") has package: " + data[0]);
+ evt.pkg = data[0];
+ if("load" == type && evt.pkg){
+ evt.type = newType;
+ }else{
+ if(evt.callbacks && evt.callbacks.length){
+ evt.callbacks.shift()("error", {}, evt, evt.input);
+ }
+ }
+ },
+ _gotMeta: function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+ dojo.debug("_gotMeta(" + evt.name + ")");
+
+ var cached = dojo.docs._getCache(evt.pkg, evt.name, "meta", "functions", evt.id);
+ if(cached.summary){
+ data.summary = cached.summary;
+ }
+ if(evt.callbacks && evt.callbacks.length){
+ evt.callbacks.shift()(type, data, evt, evt.input);
+ }
+ },
+ getSrc: function(/*String*/ name, /*Function*/ callback, /*String?*/ id){
+ // summary: Gets src file (created by the doc parser)
+ dojo.debug("getSrc(" + name + ")");
+ if(!id){
+ id = "_";
+ }
+ },
+ getDoc: function(/*String*/ name, /*Function*/ callback, /*String?*/ id){
+ // summary: Gets external documentation stored on Jot for a given function
+ dojo.debug("getDoc(" + name + ")");
+
+ if(!id){
+ id = "_";
+ }
+
+ var input = {};
+
+ input.type = "doc";
+ input.name = name;
+ input.callbacks = [callback];
+ },
+ _gotDoc: function(/*String*/ type, /*Array*/ data, /*Object*/ evt, /*Object*/ input){
+ dojo.debug("_gotDoc(" + evt.type + ")");
+
+ evt[evt.type] = data;
+ if(evt.expects && evt.expects.doc){
+ for(var i = 0, expect; expect = evt.expects.doc[i]; i++){
+ if(!(expect in evt)){
+ dojo.debug("_gotDoc() waiting for more data");
+ return;
+ }
+ }
+ }
+
+ var cache = dojo.docs._getCache(evt.pkg, "meta", "functions", evt.name, evt.id, "meta");
+
+ var description = evt.fn.description;
+ cache.description = description;
+ data = {
+ returns: evt.fn.returns,
+ id: evt.id,
+ variables: []
+ }
+ if(!cache.parameters){
+ cache.parameters = {};
+ }
+ for(var i = 0, param; param = evt.param[i]; i++){
+ var fName = param["DocParamForm/name"];
+ if(!cache.parameters[fName]){
+ cache.parameters[fName] = {};
+ }
+ cache.parameters[fName].description = param["DocParamForm/desc"]
+ }
+
+ data.description = cache.description;
+ data.parameters = cache.parameters;
+
+ evt.type = "doc";
+
+ if(evt.callbacks && evt.callbacks.length){
+ evt.callbacks.shift()("load", data, evt, input);
+ }
+ },
+ getPkgDoc: function(/*String*/ name, /*Function*/ callback){
+ // summary: Gets external documentation stored on Jot for a given package
+ dojo.debug("getPkgDoc(" + name + ")");
+ var input = {};
+ },
+ getPkgInfo: function(/*String*/ name, /*Function*/ callback){
+ // summary: Gets a combination of the metadata and external documentation for a given package
+ dojo.debug("getPkgInfo(" + name + ")");
+
+ var input = {
+ expects: {
+ pkginfo: ["pkgmeta", "pkgdoc"]
+ },
+ callback: callback
+ };
+ dojo.docs.getPkgMeta(input, name, dojo.docs._getPkgInfo);
+ dojo.docs.getPkgDoc(input, name, dojo.docs._getPkgInfo);
+ },
+ _getPkgInfo: function(/*String*/ type, /*Object*/ data, /*Object*/ evt){
+ dojo.debug("_getPkgInfo() for " + evt.type);
+ var input = {};
+ var results = {};
+ if(typeof key == "object"){
+ input = key;
+ input[evt.type] = data;
+ if(input.expects && input.expects.pkginfo){
+ for(var i = 0, expect; expect = input.expects.pkginfo[i]; i++){
+ if(!(expect in input)){
+ dojo.debug("_getPkgInfo() waiting for more data");
+ return;
+ }
+ }
+ }
+ results = input.pkgmeta;
+ results.description = input.pkgdoc;
+ }
+
+ if(input.callback){
+ input.callback("load", results, evt);
+ }
+ },
+ getInfo: function(/*String*/ name, /*Function*/ callback){
+ dojo.debug("getInfo(" + name + ")");
+ var input = {
+ expects: {
+ "info": ["meta", "doc"]
+ },
+ callback: callback
+ }
+ dojo.docs.getMeta(input, name, dojo.docs._getInfo);
+ dojo.docs.getDoc(input, name, dojo.docs._getInfo);
+ },
+ _getInfo: function(/*String*/ type, /*String*/ data, /*Object*/ evt, /*Object*/ input){
+ dojo.debug("_getInfo(" + evt.type + ")");
+ if(input && input.expects && input.expects.info){
+ input[evt.type] = data;
+ for(var i = 0, expect; expect = input.expects.info[i]; i++){
+ if(!(expect in input)){
+ dojo.debug("_getInfo() waiting for more data");
+ return;
+ }
+ }
+ }
+
+ if(input.callback){
+ input.callback("load", dojo.docs._getCache(evt.pkg, "meta", "functions", evt.name, evt.id, "meta"), evt, input);
+ }
+ },
+ _getMainText: function(/*String*/ text){
+ // summary: Grabs the innerHTML from a Jot Rech Text node
+ dojo.debug("_getMainText()");
+ return text.replace(/^/, "").replace(/<\/html>$/, "").replace(/<\w+\s*\/>/g, "");
+ },
+ getPackageMeta: function(/*Object*/ input){
+ dojo.debug("getPackageMeta(): " + input.package);
+ return this.require(input.package + "/meta", input.sync);
+ },
+ getFunctionMeta: function(/*Object*/ input){
+ var package = input.package || "";
+ var name = input.name;
+ var id = input.id || "_";
+ dojo.debug("getFunctionMeta(): " + name);
+
+ if(!name) return;
+
+ if(package){
+ return this.require(package + "/meta/functions/" + name + "/" + id + "/meta");
+ }else{
+ this.getFunctionNames();
+ }
+ },
+ getFunctionDocumentation: function(/*Object*/ input){
+ var package = input.package || "";
+ var name = input.name;
+ var id = input.id || "_";
+ dojo.debug("getFunctionDocumentation(): " + name);
+
+ if(!name) return;
+
+ if(package){
+ return this.require(package + "/meta/functions/" + name + "/" + id + "/documentation");
+ }
+ },
+ _onDocSearch: function(/*Object*/ input){
+ var _this = this;
+ var name = input.name.toLowerCase();
+ if(!name) return;
+
+ this.getFunctionNames().addCallback(function(data){
+ dojo.debug("_onDocSearch(): function names loaded for " + name);
+
+ var output = [];
+ var list = [];
+ var closure = function(pkg, fn) {
+ return function(data){
+ dojo.debug("_onDocSearch(): package meta loaded for: " + pkg);
+ if(data.functions){
+ var functions = data.functions;
+ for(var key in functions){
+ if(fn == key){
+ var ids = functions[key];
+ for(var id in ids){
+ var fnMeta = ids[id];
+ output.push({
+ package: pkg,
+ name: fn,
+ id: id,
+ summary: fnMeta.summary
+ });
+ }
+ }
+ }
+ }
+ return output;
+ }
+ }
+
+ pkgLoop:
+ for(var pkg in data){
+ if(pkg.toLowerCase() == name){
+ name = pkg;
+ dojo.debug("_onDocSearch found a package");
+ //dojo.docs._onDocSelectPackage(input);
+ return;
+ }
+ for(var i = 0, fn; fn = data[pkg][i]; i++){
+ if(fn.toLowerCase().indexOf(name) != -1){
+ dojo.debug("_onDocSearch(): Search matched " + fn);
+ var meta = _this.getPackageMeta({package: pkg});
+ meta.addCallback(closure(pkg, fn));
+ list.push(meta);
+
+ // Build a list of all packages that need to be loaded and their loaded state.
+ continue pkgLoop;
+ }
+ }
+ }
+
+ list = new dojo.DeferredList(list);
+ list.addCallback(function(results){
+ dojo.debug("_onDocSearch(): All packages loaded");
+ _this._printFunctionResults(results[0][1]);
+ });
+ });
+ },
+ _onDocSearchFn: function(/*String*/ type, /*Array*/ data, /*Object*/ evt){
+ dojo.debug("_onDocSearchFn(" + evt.name + ")");
+
+ var name = evt.name || evt.pkg;
+
+ dojo.debug("_onDocSearchFn found a function");
+
+ evt.pkgs = packages;
+ evt.pkg = name;
+ evt.loaded = 0;
+ for(var i = 0, pkg; pkg = packages[i]; i++){
+ dojo.docs.getPkgMeta(evt, pkg, dojo.docs._onDocResults);
+ }
+ },
+ _onPkgResults: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input){
+ dojo.debug("_onPkgResults(" + evt.type + ")");
+ var description = "";
+ var path = "";
+ var methods = {};
+ var requires = {};
+ if(input){
+ input[evt.type] = data;
+ if(input.expects && input.expects.pkgresults){
+ for(var i = 0, expect; expect = input.expects.pkgresults[i]; i++){
+ if(!(expect in input)){
+ dojo.debug("_onPkgResults() waiting for more data");
+ return;
+ }
+ }
+ }
+ path = input.pkgdoc.path;
+ description = input.pkgdoc.description;
+ methods = input.pkgmeta.methods;
+ requires = input.pkgmeta.requires;
+ }
+ var pkg = evt.name.replace("_", "*");
+ var results = {
+ path: path,
+ description: description,
+ size: 0,
+ methods: [],
+ pkg: pkg,
+ requires: requires
+ }
+ var rePrivate = /_[^.]+$/;
+ for(var method in methods){
+ if(!rePrivate.test(method)){
+ for(var pId in methods[method]){
+ results.methods.push({
+ pkg: pkg,
+ name: method,
+ id: pId,
+ summary: methods[method][pId].summary
+ })
+ }
+ }
+ }
+ results.size = results.methods.length;
+ dojo.docs._printPkgResult(results);
+ },
+ _onDocResults: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input){
+ dojo.debug("_onDocResults(" + evt.name + "/" + input.pkg + ") " + type);
+ ++input.loaded;
+
+ if(input.loaded == input.pkgs.length){
+ var pkgs = input.pkgs;
+ var name = input.pkg;
+ var results = {methods: []};
+ var rePrivate = /_[^.]+$/;
+ data = dojo.docs._cache;
+
+ for(var i = 0, pkg; pkg = pkgs[i]; i++){
+ var methods = dojo.docs._getCache(pkg, "meta", "methods");
+ for(var fn in methods){
+ if(fn.toLowerCase().indexOf(name) == -1){
+ continue;
+ }
+ if(fn != "requires" && !rePrivate.test(fn)){
+ for(var pId in methods[fn]){
+ var result = {
+ pkg: pkg,
+ name: fn,
+ id: "_",
+ summary: ""
+ }
+ if(methods[fn][pId].summary){
+ result.summary = methods[fn][pId].summary;
+ }
+ results.methods.push(result);
+ }
+ }
+ }
+ }
+
+ dojo.debug("Publishing docResults");
+ dojo.docs._printFnResults(results);
+ }
+ },
+ _printFunctionResults: function(results){
+ dojo.debug("_printFnResults(): called");
+ // summary: Call this function to send the /docs/function/results topic
+ },
+ _printPkgResult: function(results){
+ dojo.debug("_printPkgResult(): called");
+ },
+ _onDocSelectFunction: function(/*Object*/ input){
+ // summary: Get doc, meta, and src
+ var name = input.name;
+ var package = input.package || "";
+ var id = input.id || "_";
+ dojo.debug("_onDocSelectFunction(" + name + ")");
+ if(!name || !package) return false;
+
+ var pkgMeta = this.getPackageMeta({package: package});
+ var meta = this.getFunctionMeta({package: package, name: name, id: id});
+ var doc = this.getFunctionDocumentation({package: package, name: name, id: id});
+
+ var list = new dojo.DeferredList([pkgMeta, meta, doc]);
+ list.addCallback(function(results){
+ dojo.debug("_onDocSelectFunction() loaded");
+ for(var i = 0, result; result = results[i]; i++){
+ dojo.debugShallow(result[1]);
+ }
+ });
+
+ return list;
+ },
+ _onDocSelectPackage: function(/*Object*/ input){
+ dojo.debug("_onDocSelectPackage(" + input.name + ")")
+ input.expects = {
+ "pkgresults": ["pkgmeta", "pkgdoc"]
+ };
+ dojo.docs.getPkgMeta(input, input.name, dojo.docs._onPkgResults);
+ dojo.docs.getPkgDoc(input, input.name, dojo.docs._onPkgResults);
+ },
+ _onDocSelectResults: function(/*String*/ type, /*Object*/ data, /*Object*/ evt, /*Object*/ input){
+ dojo.debug("_onDocSelectResults(" + evt.type + ", " + evt.name + ")");
+ if(evt.type == "meta"){
+ dojo.docs.getPkgMeta(input, evt.pkg, dojo.docs._onDocSelectResults);
+ }
+ if(input){
+ input[evt.type] = data;
+ if(input.expects && input.expects.docresults){
+ for(var i = 0, expect; expect = input.expects.docresults[i]; i++){
+ if(!(expect in input)){
+ dojo.debug("_onDocSelectResults() waiting for more data");
+ return;
+ }
+ }
+ }
+ }
+
+ dojo.docs._printFunctionDetail(input);
+ },
+
+ _printFunctionDetail: function(results) {
+ // summary: Call this function to send the /docs/function/detail topic event
+ },
+
+ selectFunction: function(/*String*/ name, /*String?*/ id){
+ // summary: The combined information
+ },
+ savePackage: function(/*Object*/ callbackObject, /*String*/ callback, /*Object*/ parameters){
+ dojo.event.kwConnect({
+ srcObj: dojo.docs,
+ srcFunc: "_savedPkgRpc",
+ targetObj: callbackObject,
+ targetFunc: callback,
+ once: true
+ });
+
+ var props = {};
+ var cache = dojo.docs._getCache(parameters.pkg, "meta");
+
+ var i = 1;
+
+ if(!cache.path){
+ var path = "id";
+ props[["pname", i].join("")] = "DocPkgForm/require";
+ props[["pvalue", i++].join("")] = parameters.pkg;
+ }else{
+ var path = cache.path;
+ }
+
+ props.form = "//DocPkgForm";
+ props.path = ["/WikiHome/DojoDotDoc/", path].join("");
+
+ if(parameters.description){
+ props[["pname", i].join("")] = "main/text";
+ props[["pvalue", i++].join("")] = parameters.description;
+ }
+
+ dojo.docs._rpc.callRemote("saveForm", props).addCallbacks(dojo.docs._pkgRpc, dojo.docs._pkgRpc);
+ },
+ _pkgRpc: function(data){
+ if(data.name){
+ dojo.docs._getCache(data["DocPkgForm/require"], "meta").path = data.name;
+ dojo.docs._savedPkgRpc("load");
+ }else{
+ dojo.docs._savedPkgRpc("error");
+ }
+ },
+ _savedPkgRpc: function(type){
+ },
+ functionPackages: function(/*String*/ name, /*Function*/ callback, /*Object*/ input){
+ // summary: Gets the package associated with a function and stores it in the .pkg value of input
+ dojo.debug("functionPackages() name: " + name);
+
+ if(!input){
+ input = {};
+ }
+ if(!input.callbacks){
+ input.callbacks = [];
+ }
+
+ input.type = "function_names";
+ input.name = name;
+ input.callbacks.unshift(callback);
+ input.callbacks.unshift(dojo.docs._functionPackages);
+ },
+ _functionPackages: function(/*String*/ type, /*Array*/ data, /*Object*/ evt){
+ dojo.debug("_functionPackages() name: " + evt.name);
+ evt.pkg = '';
+
+ var results = [];
+ var data = dojo.docs._cache['function_names'];
+ for(var key in data){
+ if(dojo.lang.inArray(data[key], evt.name)){
+ dojo.debug("_functionPackages() package: " + key);
+ results.push(key);
+ }
+ }
+
+ if(evt.callbacks && evt.callbacks.length){
+ evt.callbacks.shift()(type, results, evt, evt.input);
+ }
+ },
+ setUserName: function(/*String*/ name){
+ dojo.docs._userName = name;
+ if(name && dojo.docs._password){
+ dojo.docs._logIn();
+ }
+ },
+ setPassword: function(/*String*/ password){
+ dojo.docs._password = password;
+ if(password && dojo.docs._userName){
+ dojo.docs._logIn();
+ }
+ },
+ _logIn: function(){
+ dojo.io.bind({
+ url: dojo.docs._rpc.serviceUrl.toString(),
+ method: "post",
+ mimetype: "text/json",
+ content: {
+ username: dojo.docs._userName,
+ password: dojo.docs._password
+ },
+ load: function(type, data){
+ if(data.error){
+ dojo.docs.logInSuccess();
+ }else{
+ dojo.docs.logInFailure();
+ }
+ },
+ error: function(){
+ dojo.docs.logInFailure();
+ }
+ });
+ },
+ logInSuccess: function(){},
+ logInFailure: function(){},
+ _set: function(/*Object*/ base, /*String...*/ keys, /*String*/ value){
+ var args = [];
+ for(var i = 0, arg; arg = arguments[i]; i++){
+ args.push(arg);
+ }
+
+ if(args.length < 3) return;
+ base = args.shift();
+ value = args.pop();
+ var key = args.pop();
+ for(var i = 0, arg; arg = args[i]; i++){
+ if(typeof base[arg] != "object"){
+ base[arg] = {};
+ }
+ base = base[arg];
+ }
+ base[key] = value;
+ },
+ _getCache: function(/*String...*/ keys){
+ var obj = dojo.docs._cache;
+ for(var i = 0; i < arguments.length; i++){
+ var arg = arguments[i];
+ if(!obj[arg]){
+ obj[arg] = {};
+ }
+ obj = obj[arg];
+ }
+ return obj;
+ }
+});
+
+dojo.event.topic.subscribe("/docs/search", dojo.docs, "_onDocSearch");
+dojo.event.topic.subscribe("/docs/function/select", dojo.docs, "_onDocSelectFunction");
+dojo.event.topic.subscribe("/docs/package/select", dojo.docs, "_onDocSelectPackage");
+
+dojo.event.topic.registerPublisher("/docs/function/results", dojo.docs, "_printFunctionResults");
+dojo.event.topic.registerPublisher("/docs/function/detail", dojo.docs, "_printFunctionDetail");
+dojo.event.topic.registerPublisher("/docs/package/detail", dojo.docs, "_printPkgResult");
\ No newline at end of file
diff --git a/source/web/scripts/ajax/dojo/src/dom.js b/source/web/scripts/ajax/dojo/src/dom.js
new file mode 100644
index 0000000000..15c707999d
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/dom.js
@@ -0,0 +1,560 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.dom");
+
+dojo.dom.ELEMENT_NODE = 1;
+dojo.dom.ATTRIBUTE_NODE = 2;
+dojo.dom.TEXT_NODE = 3;
+dojo.dom.CDATA_SECTION_NODE = 4;
+dojo.dom.ENTITY_REFERENCE_NODE = 5;
+dojo.dom.ENTITY_NODE = 6;
+dojo.dom.PROCESSING_INSTRUCTION_NODE = 7;
+dojo.dom.COMMENT_NODE = 8;
+dojo.dom.DOCUMENT_NODE = 9;
+dojo.dom.DOCUMENT_TYPE_NODE = 10;
+dojo.dom.DOCUMENT_FRAGMENT_NODE = 11;
+dojo.dom.NOTATION_NODE = 12;
+
+dojo.dom.dojoml = "http://www.dojotoolkit.org/2004/dojoml";
+
+/**
+ * comprehensive list of XML namespaces
+**/
+dojo.dom.xmlns = {
+ // summary
+ // aliases for various common XML namespaces
+ svg : "http://www.w3.org/2000/svg",
+ smil : "http://www.w3.org/2001/SMIL20/",
+ mml : "http://www.w3.org/1998/Math/MathML",
+ cml : "http://www.xml-cml.org",
+ xlink : "http://www.w3.org/1999/xlink",
+ xhtml : "http://www.w3.org/1999/xhtml",
+ xul : "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
+ xbl : "http://www.mozilla.org/xbl",
+ fo : "http://www.w3.org/1999/XSL/Format",
+ xsl : "http://www.w3.org/1999/XSL/Transform",
+ xslt : "http://www.w3.org/1999/XSL/Transform",
+ xi : "http://www.w3.org/2001/XInclude",
+ xforms : "http://www.w3.org/2002/01/xforms",
+ saxon : "http://icl.com/saxon",
+ xalan : "http://xml.apache.org/xslt",
+ xsd : "http://www.w3.org/2001/XMLSchema",
+ dt: "http://www.w3.org/2001/XMLSchema-datatypes",
+ xsi : "http://www.w3.org/2001/XMLSchema-instance",
+ rdf : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+ rdfs : "http://www.w3.org/2000/01/rdf-schema#",
+ dc : "http://purl.org/dc/elements/1.1/",
+ dcq: "http://purl.org/dc/qualifiers/1.0",
+ "soap-env" : "http://schemas.xmlsoap.org/soap/envelope/",
+ wsdl : "http://schemas.xmlsoap.org/wsdl/",
+ AdobeExtensions : "http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/"
+};
+
+dojo.dom.isNode = function(/* object */wh){
+ // summary:
+ // checks to see if wh is actually a node.
+ if(typeof Element == "function") {
+ try {
+ return wh instanceof Element; // boolean
+ } catch(e) {}
+ } else {
+ // best-guess
+ return wh && !isNaN(wh.nodeType); // boolean
+ }
+}
+
+dojo.dom.getUniqueId = function(){
+ // summary:
+ // returns a unique string for use with any DOM element
+ var _document = dojo.doc();
+ do {
+ var id = "dj_unique_" + (++arguments.callee._idIncrement);
+ }while(_document.getElementById(id));
+ return id; // string
+}
+dojo.dom.getUniqueId._idIncrement = 0;
+
+dojo.dom.firstElement = dojo.dom.getFirstChildElement = function(/* Element */parentNode, /* string? */tagName){
+ // summary:
+ // returns the first child element matching tagName
+ var node = parentNode.firstChild;
+ while(node && node.nodeType != dojo.dom.ELEMENT_NODE){
+ node = node.nextSibling;
+ }
+ if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) {
+ node = dojo.dom.nextElement(node, tagName);
+ }
+ return node; // Element
+}
+
+dojo.dom.lastElement = dojo.dom.getLastChildElement = function(/* Element */parentNode, /* string? */tagName){
+ // summary:
+ // returns the last child element matching tagName
+ var node = parentNode.lastChild;
+ while(node && node.nodeType != dojo.dom.ELEMENT_NODE) {
+ node = node.previousSibling;
+ }
+ if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) {
+ node = dojo.dom.prevElement(node, tagName);
+ }
+ return node; // Element
+}
+
+dojo.dom.nextElement = dojo.dom.getNextSiblingElement = function(/* Node */node, /* string? */tagName){
+ // summary:
+ // returns the next sibling element matching tagName
+ if(!node) { return null; }
+ do {
+ node = node.nextSibling;
+ } while(node && node.nodeType != dojo.dom.ELEMENT_NODE);
+
+ if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) {
+ return dojo.dom.nextElement(node, tagName);
+ }
+ return node; // Element
+}
+
+dojo.dom.prevElement = dojo.dom.getPreviousSiblingElement = function(/* Node */node, /* string? */tagName){
+ // summary:
+ // returns the previous sibling element matching tagName
+ if(!node) { return null; }
+ if(tagName) { tagName = tagName.toLowerCase(); }
+ do {
+ node = node.previousSibling;
+ } while(node && node.nodeType != dojo.dom.ELEMENT_NODE);
+
+ if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) {
+ return dojo.dom.prevElement(node, tagName);
+ }
+ return node; // Element
+}
+
+// TODO: hmph
+/*this.forEachChildTag = function(node, unaryFunc) {
+ var child = this.getFirstChildTag(node);
+ while(child) {
+ if(unaryFunc(child) == "break") { break; }
+ child = this.getNextSiblingTag(child);
+ }
+}*/
+
+dojo.dom.moveChildren = function(/*Element*/srcNode, /*Element*/destNode, /*boolean?*/trim){
+ // summary:
+ // Moves children from srcNode to destNode and returns the count of
+ // children moved; will trim off text nodes if trim == true
+ var count = 0;
+ if(trim) {
+ while(srcNode.hasChildNodes() &&
+ srcNode.firstChild.nodeType == dojo.dom.TEXT_NODE) {
+ srcNode.removeChild(srcNode.firstChild);
+ }
+ while(srcNode.hasChildNodes() &&
+ srcNode.lastChild.nodeType == dojo.dom.TEXT_NODE) {
+ srcNode.removeChild(srcNode.lastChild);
+ }
+ }
+ while(srcNode.hasChildNodes()){
+ destNode.appendChild(srcNode.firstChild);
+ count++;
+ }
+ return count; // number
+}
+
+dojo.dom.copyChildren = function(/*Element*/srcNode, /*Element*/destNode, /*boolean?*/trim){
+ // summary:
+ // Copies children from srcNde to destNode and returns the count of
+ // children copied; will trim off text nodes if trim == true
+ var clonedNode = srcNode.cloneNode(true);
+ return this.moveChildren(clonedNode, destNode, trim); // number
+}
+
+dojo.dom.replaceChildren = function(/*Element*/node, /*Node*/newChild){
+ // summary:
+ // Removes all children of node and appends newChild. All the existing
+ // children will be destroyed.
+ // FIXME: what if newChild is an array-like object?
+ var nodes = [];
+ if(dojo.render.html.ie){
+ for(var i=0;i 0){
+ return ancestors[0]; // Node
+ }
+
+ node = node.parentNode;
+ }
+ if(returnFirstHit){ return null; }
+ return ancestors; // array
+}
+
+dojo.dom.getAncestorsByTag = function(/*Node*/node, /*String*/tag, /*boolean?*/returnFirstHit){
+ // summary:
+ // returns all ancestors matching tag (as tagName), will only return
+ // first one if returnFirstHit
+ tag = tag.toLowerCase();
+ return dojo.dom.getAncestors(node, function(el){
+ return ((el.tagName)&&(el.tagName.toLowerCase() == tag));
+ }, returnFirstHit); // Node || array
+}
+
+dojo.dom.getFirstAncestorByTag = function(/*Node*/node, /*string*/tag){
+ // summary:
+ // Returns first ancestor of node with tag tagName
+ return dojo.dom.getAncestorsByTag(node, tag, true); // Node
+}
+
+dojo.dom.isDescendantOf = function(/* Node */node, /* Node */ancestor, /* boolean? */guaranteeDescendant){
+ // summary
+ // Returns boolean if node is a descendant of ancestor
+ // guaranteeDescendant allows us to be a "true" isDescendantOf function
+ if(guaranteeDescendant && node) { node = node.parentNode; }
+ while(node) {
+ if(node == ancestor){
+ return true; // boolean
+ }
+ node = node.parentNode;
+ }
+ return false; // boolean
+}
+
+dojo.dom.innerXML = function(/*Node*/node){
+ // summary:
+ // Implementation of MS's innerXML function.
+ if(node.innerXML){
+ return node.innerXML; // string
+ }else if (node.xml){
+ return node.xml; // string
+ }else if(typeof XMLSerializer != "undefined"){
+ return (new XMLSerializer()).serializeToString(node); // string
+ }
+}
+
+dojo.dom.createDocument = function(){
+ // summary:
+ // cross-browser implementation of creating an XML document object.
+ var doc = null;
+ var _document = dojo.doc();
+
+ if(!dj_undef("ActiveXObject")){
+ var prefixes = [ "MSXML2", "Microsoft", "MSXML", "MSXML3" ];
+ for(var i = 0; i1) {
+ var _document = dojo.doc();
+ dojo.dom.replaceChildren(node, _document.createTextNode(text));
+ return text; // string
+ } else {
+ if(node.textContent != undefined){ //FF 1.5
+ return node.textContent; // string
+ }
+ var _result = "";
+ if (node == null) { return _result; }
+ for (var i = 0; i < node.childNodes.length; i++) {
+ switch (node.childNodes[i].nodeType) {
+ case 1: // ELEMENT_NODE
+ case 5: // ENTITY_REFERENCE_NODE
+ _result += dojo.dom.textContent(node.childNodes[i]);
+ break;
+ case 3: // TEXT_NODE
+ case 2: // ATTRIBUTE_NODE
+ case 4: // CDATA_SECTION_NODE
+ _result += node.childNodes[i].nodeValue;
+ break;
+ default:
+ break;
+ }
+ }
+ return _result; // string
+ }
+}
+
+dojo.dom.hasParent = function(/*Node*/node){
+ // summary:
+ // returns whether or not node is a child of another node.
+ return Boolean(node && node.parentNode && dojo.dom.isNode(node.parentNode)); // boolean
+}
+
+/**
+ * Examples:
+ *
+ * myFooNode =
+ * isTag(myFooNode, "foo"); // returns "foo"
+ * isTag(myFooNode, "bar"); // returns ""
+ * isTag(myFooNode, "FOO"); // returns ""
+ * isTag(myFooNode, "hey", "foo", "bar"); // returns "foo"
+**/
+dojo.dom.isTag = function(/* Node */node /* ... */){
+ // summary:
+ // determines if node has any of the provided tag names and returns
+ // the tag name that matches, empty string otherwise.
+ if(node && node.tagName) {
+ for(var i=1; i=0; i=i-1){
+ var el = na[i];
+ try{
+ if(el && el["__clobberAttrs__"]){
+ for(var j=0; j= 65 && unifiedCharCode <= 90 && evt.shiftKey == false){
+ unifiedCharCode += 32;
+ }
+ if(unifiedCharCode >= 1 && unifiedCharCode <= 26 && evt.ctrlKey){
+ unifiedCharCode += 96; // 001-032 = ctrl+[a-z]
+ }
+ evt.key = String.fromCharCode(unifiedCharCode);
+ }
+ }
+ } else if(evt["type"] == "keypress"){
+ if(dojo.render.html.opera){
+ if(evt.which == 0){
+ evt.key = evt.keyCode;
+ }else if(evt.which > 0){
+ switch(evt.which){
+ case evt.KEY_SHIFT:
+ case evt.KEY_CTRL:
+ case evt.KEY_ALT:
+ case evt.KEY_CAPS_LOCK:
+ case evt.KEY_NUM_LOCK:
+ case evt.KEY_SCROLL_LOCK:
+ break;
+ case evt.KEY_PAUSE:
+ case evt.KEY_TAB:
+ case evt.KEY_BACKSPACE:
+ case evt.KEY_ENTER:
+ case evt.KEY_ESCAPE:
+ evt.key = evt.which;
+ break;
+ default:
+ var unifiedCharCode = evt.which;
+ if((evt.ctrlKey || evt.altKey || evt.metaKey) && (evt.which >= 65 && evt.which <= 90 && evt.shiftKey == false)){
+ unifiedCharCode += 32;
+ }
+ evt.key = String.fromCharCode(unifiedCharCode);
+ }
+ }
+ }else if(dojo.render.html.ie){ // catch some IE keys that are hard to get in keyDown
+ // key combinations were handled in onKeyDown
+ if(!evt.ctrlKey && !evt.altKey && evt.keyCode >= evt.KEY_SPACE){
+ evt.key = String.fromCharCode(evt.keyCode);
+ }
+ }else if(dojo.render.html.safari){
+ switch(evt.keyCode){
+ case 25: evt.key = evt.KEY_TAB; evt.shift = true;break;
+ case 63232: evt.key = evt.KEY_UP_ARROW; break;
+ case 63233: evt.key = evt.KEY_DOWN_ARROW; break;
+ case 63234: evt.key = evt.KEY_LEFT_ARROW; break;
+ case 63235: evt.key = evt.KEY_RIGHT_ARROW; break;
+ case 63236: evt.key = evt.KEY_F1; break;
+ case 63237: evt.key = evt.KEY_F2; break;
+ case 63238: evt.key = evt.KEY_F3; break;
+ case 63239: evt.key = evt.KEY_F4; break;
+ case 63240: evt.key = evt.KEY_F5; break;
+ case 63241: evt.key = evt.KEY_F6; break;
+ case 63242: evt.key = evt.KEY_F7; break;
+ case 63243: evt.key = evt.KEY_F8; break;
+ case 63244: evt.key = evt.KEY_F9; break;
+ case 63245: evt.key = evt.KEY_F10; break;
+ case 63246: evt.key = evt.KEY_F11; break;
+ case 63247: evt.key = evt.KEY_F12; break;
+ case 63250: evt.key = evt.KEY_PAUSE; break;
+ case 63272: evt.key = evt.KEY_DELETE; break;
+ case 63273: evt.key = evt.KEY_HOME; break;
+ case 63275: evt.key = evt.KEY_END; break;
+ case 63276: evt.key = evt.KEY_PAGE_UP; break;
+ case 63277: evt.key = evt.KEY_PAGE_DOWN; break;
+ case 63302: evt.key = evt.KEY_INSERT; break;
+ case 63248://prtscr
+ case 63249://scrolllock
+ case 63289://numlock
+ break;
+ default:
+ evt.key = evt.charCode >= evt.KEY_SPACE ? String.fromCharCode(evt.charCode) : evt.keyCode;
+ }
+ }else{
+ evt.key = evt.charCode > 0 ? String.fromCharCode(evt.charCode) : evt.keyCode;
+ }
+ }
+ }
+ if(dojo.render.html.ie){
+ if(!evt.target){ evt.target = evt.srcElement; }
+ if(!evt.currentTarget){ evt.currentTarget = (sender ? sender : evt.srcElement); }
+ if(!evt.layerX){ evt.layerX = evt.offsetX; }
+ if(!evt.layerY){ evt.layerY = evt.offsetY; }
+ // FIXME: scroll position query is duped from dojo.html to avoid dependency on that entire module
+ // DONOT replace the following to use dojo.body(), in IE, document.documentElement should be used
+ // here rather than document.body
+ var doc = (evt.srcElement && evt.srcElement.ownerDocument) ? evt.srcElement.ownerDocument : document;
+ var docBody = ((dojo.render.html.ie55)||(doc["compatMode"] == "BackCompat")) ? doc.body : doc.documentElement;
+ if(!evt.pageX){ evt.pageX = evt.clientX + (docBody.scrollLeft || 0) }
+ if(!evt.pageY){ evt.pageY = evt.clientY + (docBody.scrollTop || 0) }
+ // mouseover
+ if(evt.type == "mouseover"){ evt.relatedTarget = evt.fromElement; }
+ // mouseout
+ if(evt.type == "mouseout"){ evt.relatedTarget = evt.toElement; }
+ this.currentEvent = evt;
+ evt.callListener = this.callListener;
+ evt.stopPropagation = this._stopPropagation;
+ evt.preventDefault = this._preventDefault;
+ }
+ return evt; // Event
+ }
+
+ this.stopEvent = function(/*Event*/evt){
+ // summary:
+ // prevents propigation and clobbers the default action of the
+ // passed event
+ // evt: Optional for IE. The native event object.
+ if(window.event){
+ evt.cancelBubble = true;
+ evt.returnValue = false;
+ }else{
+ evt.preventDefault();
+ evt.stopPropagation();
+ }
+ }
+}
diff --git a/source/web/scripts/ajax/dojo/src/event/common.js b/source/web/scripts/ajax/dojo/src/event/common.js
new file mode 100644
index 0000000000..0756265f4e
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/event/common.js
@@ -0,0 +1,885 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.event.common");
+
+dojo.require("dojo.lang.array");
+dojo.require("dojo.lang.extras");
+dojo.require("dojo.lang.func");
+
+// TODO: connection filter functions
+// these are functions that accept a method invocation (like around
+// advice) and return a boolean based on it. That value determines
+// whether or not the connection proceeds. It could "feel" like around
+// advice for those who know what it is (calling proceed() or not),
+// but I think presenting it as a "filter" and/or calling it with the
+// function args and not the MethodInvocation might make it more
+// palletable to "normal" users than around-advice currently is
+// TODO: execution scope mangling
+// YUI's event facility by default executes listeners in the context
+// of the source object. This is very odd, but should probably be
+// supported as an option (both for the source and for the dest). It
+// can be thought of as a connection-specific hitch().
+// TODO: more resiliency for 4+ arguments to connect()
+
+dojo.event = new function(){
+ this._canTimeout = dojo.lang.isFunction(dj_global["setTimeout"])||dojo.lang.isAlien(dj_global["setTimeout"]);
+
+ // FIXME: where should we put this method (not here!)?
+ function interpolateArgs(args, searchForNames){
+ var dl = dojo.lang;
+ var ao = {
+ srcObj: dj_global,
+ srcFunc: null,
+ adviceObj: dj_global,
+ adviceFunc: null,
+ aroundObj: null,
+ aroundFunc: null,
+ adviceType: (args.length>2) ? args[0] : "after",
+ precedence: "last",
+ once: false,
+ delay: null,
+ rate: 0,
+ adviceMsg: false
+ };
+
+ switch(args.length){
+ case 0: return;
+ case 1: return;
+ case 2:
+ ao.srcFunc = args[0];
+ ao.adviceFunc = args[1];
+ break;
+ case 3:
+ if((dl.isObject(args[0]))&&(dl.isString(args[1]))&&(dl.isString(args[2]))){
+ ao.adviceType = "after";
+ ao.srcObj = args[0];
+ ao.srcFunc = args[1];
+ ao.adviceFunc = args[2];
+ }else if((dl.isString(args[1]))&&(dl.isString(args[2]))){
+ ao.srcFunc = args[1];
+ ao.adviceFunc = args[2];
+ }else if((dl.isObject(args[0]))&&(dl.isString(args[1]))&&(dl.isFunction(args[2]))){
+ ao.adviceType = "after";
+ ao.srcObj = args[0];
+ ao.srcFunc = args[1];
+ var tmpName = dl.nameAnonFunc(args[2], ao.adviceObj, searchForNames);
+ ao.adviceFunc = tmpName;
+ }else if((dl.isFunction(args[0]))&&(dl.isObject(args[1]))&&(dl.isString(args[2]))){
+ ao.adviceType = "after";
+ ao.srcObj = dj_global;
+ var tmpName = dl.nameAnonFunc(args[0], ao.srcObj, searchForNames);
+ ao.srcFunc = tmpName;
+ ao.adviceObj = args[1];
+ ao.adviceFunc = args[2];
+ }
+ break;
+ case 4:
+ if((dl.isObject(args[0]))&&(dl.isObject(args[2]))){
+ // we can assume that we've got an old-style "connect" from
+ // the sigslot school of event attachment. We therefore
+ // assume after-advice.
+ ao.adviceType = "after";
+ ao.srcObj = args[0];
+ ao.srcFunc = args[1];
+ ao.adviceObj = args[2];
+ ao.adviceFunc = args[3];
+ }else if((dl.isString(args[0]))&&(dl.isString(args[1]))&&(dl.isObject(args[2]))){
+ ao.adviceType = args[0];
+ ao.srcObj = dj_global;
+ ao.srcFunc = args[1];
+ ao.adviceObj = args[2];
+ ao.adviceFunc = args[3];
+ }else if((dl.isString(args[0]))&&(dl.isFunction(args[1]))&&(dl.isObject(args[2]))){
+ ao.adviceType = args[0];
+ ao.srcObj = dj_global;
+ var tmpName = dl.nameAnonFunc(args[1], dj_global, searchForNames);
+ ao.srcFunc = tmpName;
+ ao.adviceObj = args[2];
+ ao.adviceFunc = args[3];
+ }else if((dl.isString(args[0]))&&(dl.isObject(args[1]))&&(dl.isString(args[2]))&&(dl.isFunction(args[3]))){
+ ao.srcObj = args[1];
+ ao.srcFunc = args[2];
+ var tmpName = dl.nameAnonFunc(args[3], dj_global, searchForNames);
+ ao.adviceObj = dj_global;
+ ao.adviceFunc = tmpName;
+ }else if(dl.isObject(args[1])){
+ ao.srcObj = args[1];
+ ao.srcFunc = args[2];
+ ao.adviceObj = dj_global;
+ ao.adviceFunc = args[3];
+ }else if(dl.isObject(args[2])){
+ ao.srcObj = dj_global;
+ ao.srcFunc = args[1];
+ ao.adviceObj = args[2];
+ ao.adviceFunc = args[3];
+ }else{
+ ao.srcObj = ao.adviceObj = ao.aroundObj = dj_global;
+ ao.srcFunc = args[1];
+ ao.adviceFunc = args[2];
+ ao.aroundFunc = args[3];
+ }
+ break;
+ case 6:
+ ao.srcObj = args[1];
+ ao.srcFunc = args[2];
+ ao.adviceObj = args[3]
+ ao.adviceFunc = args[4];
+ ao.aroundFunc = args[5];
+ ao.aroundObj = dj_global;
+ break;
+ default:
+ ao.srcObj = args[1];
+ ao.srcFunc = args[2];
+ ao.adviceObj = args[3]
+ ao.adviceFunc = args[4];
+ ao.aroundObj = args[5];
+ ao.aroundFunc = args[6];
+ ao.once = args[7];
+ ao.delay = args[8];
+ ao.rate = args[9];
+ ao.adviceMsg = args[10];
+ break;
+ }
+
+ if(dl.isFunction(ao.aroundFunc)){
+ var tmpName = dl.nameAnonFunc(ao.aroundFunc, ao.aroundObj, searchForNames);
+ ao.aroundFunc = tmpName;
+ }
+
+ if(dl.isFunction(ao.srcFunc)){
+ ao.srcFunc = dl.getNameInObj(ao.srcObj, ao.srcFunc);
+ }
+
+ if(dl.isFunction(ao.adviceFunc)){
+ ao.adviceFunc = dl.getNameInObj(ao.adviceObj, ao.adviceFunc);
+ }
+
+ if((ao.aroundObj)&&(dl.isFunction(ao.aroundFunc))){
+ ao.aroundFunc = dl.getNameInObj(ao.aroundObj, ao.aroundFunc);
+ }
+
+ if(!ao.srcObj){
+ dojo.raise("bad srcObj for srcFunc: "+ao.srcFunc);
+ }
+ if(!ao.adviceObj){
+ dojo.raise("bad adviceObj for adviceFunc: "+ao.adviceFunc);
+ }
+
+ if(!ao.adviceFunc){
+ dojo.debug("bad adviceFunc for srcFunc: "+ao.srcFunc);
+ dojo.debugShallow(ao);
+ }
+
+ return ao;
+ }
+
+ this.connect = function(/*...*/){
+ // summary:
+ // dojo.event.connect is the glue that holds most Dojo-based
+ // applications together. Most combinations of arguments are
+ // supported, with the connect() method attempting to disambiguate
+ // the implied types of positional parameters. The following will
+ // all work:
+ // dojo.event.connect("globalFunctionName1", "globalFunctionName2");
+ // dojo.event.connect(functionReference1, functionReference2);
+ // dojo.event.connect("globalFunctionName1", functionReference2);
+ // dojo.event.connect(functionReference1, "globalFunctionName2");
+ // dojo.event.connect(scope1, "functionName1", "globalFunctionName2");
+ // dojo.event.connect("globalFunctionName1", scope2, "functionName2");
+ // dojo.event.connect(scope1, "functionName1", scope2, "functionName2");
+ // dojo.event.connect("after", scope1, "functionName1", scope2, "functionName2");
+ // dojo.event.connect("before", scope1, "functionName1", scope2, "functionName2");
+ // dojo.event.connect("around", scope1, "functionName1",
+ // scope2, "functionName2",
+ // aroundFunctionReference);
+ // dojo.event.connect("around", scope1, "functionName1",
+ // scope2, "functionName2",
+ // scope3, "aroundFunctionName");
+ // dojo.event.connect("before-around", scope1, "functionName1",
+ // scope2, "functionName2",
+ // aroundFunctionReference);
+ // dojo.event.connect("after-around", scope1, "functionName1",
+ // scope2, "functionName2",
+ // aroundFunctionReference);
+ // dojo.event.connect("after-around", scope1, "functionName1",
+ // scope2, "functionName2",
+ // scope3, "aroundFunctionName");
+ // dojo.event.connect("around", scope1, "functionName1",
+ // scope2, "functionName2",
+ // scope3, "aroundFunctionName", true, 30);
+ // dojo.event.connect("around", scope1, "functionName1",
+ // scope2, "functionName2",
+ // scope3, "aroundFunctionName", null, null, 10);
+ // adviceType:
+ // Optional. String. One of "before", "after", "around",
+ // "before-around", or "after-around". FIXME
+ // srcObj:
+ // the scope in which to locate/execute the named srcFunc. Along
+ // with srcFunc, this creates a way to dereference the function to
+ // call. So if the function in question is "foo.bar", the
+ // srcObj/srcFunc pair would be foo and "bar", where "bar" is a
+ // string and foo is an object reference.
+ // srcFunc:
+ // the name of the function to connect to. When it is executed,
+ // the listener being registered with this call will be called.
+ // The adviceType defines the call order between the source and
+ // the target functions.
+ // adviceObj:
+ // the scope in which to locate/execute the named adviceFunc.
+ // adviceFunc:
+ // the name of the function being conected to srcObj.srcFunc
+ // aroundObj:
+ // the scope in which to locate/execute the named aroundFunc.
+ // aroundFunc:
+ // the name of, or a reference to, the function that will be used
+ // to mediate the advice call. Around advice requires a special
+ // unary function that will be passed a "MethodInvocation" object.
+ // These objects have several important properties, namely:
+ // - args
+ // a mutable array of arguments to be passed into the
+ // wrapped function
+ // - proceed
+ // a function that "continues" the invocation. The result
+ // of this function is the return of the wrapped function.
+ // You can then manipulate this return before passing it
+ // back out (or take further action based on it).
+ // once:
+ // boolean that determines whether or not this connect() will
+ // create a new connection if an identical connect() has already
+ // been made. Defaults to "false".
+ // delay:
+ // an optional delay (in ms), as an integer, for dispatch of a
+ // listener after the source has been fired.
+ // rate:
+ // an optional rate throttling parameter (integer, in ms). When
+ // specified, this particular connection will not fire more than
+ // once in the interval specified by the rate
+ // adviceMsg:
+ // boolean. Should the listener have all the parameters passed in
+ // as a single argument?
+
+ /*
+ ao.adviceType = args[0];
+ ao.srcObj = args[1];
+ ao.srcFunc = args[2];
+ ao.adviceObj = args[3]
+ ao.adviceFunc = args[4];
+ ao.aroundObj = args[5];
+ ao.aroundFunc = args[6];
+ ao.once = args[7];
+ ao.delay = args[8];
+ ao.rate = args[9];
+ ao.adviceMsg = args[10];
+ */
+ if(arguments.length == 1){
+ var ao = arguments[0];
+ }else{
+ var ao = interpolateArgs(arguments, true);
+ }
+ if(dojo.lang.isString(ao.srcFunc) && (ao.srcFunc.toLowerCase() == "onkey") ){
+ if(dojo.render.html.ie){
+ ao.srcFunc = "onkeydown";
+ this.connect(ao);
+ }
+ ao.srcFunc = "onkeypress";
+ }
+
+
+ if(dojo.lang.isArray(ao.srcObj) && ao.srcObj!=""){
+ var tmpAO = {};
+ for(var x in ao){
+ tmpAO[x] = ao[x];
+ }
+ var mjps = [];
+ dojo.lang.forEach(ao.srcObj, function(src){
+ if((dojo.render.html.capable)&&(dojo.lang.isString(src))){
+ src = dojo.byId(src);
+ // dojo.debug(src);
+ }
+ tmpAO.srcObj = src;
+ // dojo.debug(tmpAO.srcObj, tmpAO.srcFunc);
+ // dojo.debug(tmpAO.adviceObj, tmpAO.adviceFunc);
+ mjps.push(dojo.event.connect.call(dojo.event, tmpAO));
+ });
+ return mjps;
+ }
+
+ // FIXME: just doing a "getForMethod()" seems to be enough to put this into infinite recursion!!
+ var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc);
+ if(ao.adviceFunc){
+ var mjp2 = dojo.event.MethodJoinPoint.getForMethod(ao.adviceObj, ao.adviceFunc);
+ }
+
+ mjp.kwAddAdvice(ao);
+
+ // advanced users might want to fsck w/ the join point manually
+ return mjp; // a MethodJoinPoint object
+ }
+
+ this.log = function(/*object or funcName*/ a1, /*funcName*/ a2){
+ // summary:
+ // a function that will wrap and log all calls to the specified
+ // a1.a2() function. If only a1 is passed, it'll be used as a
+ // function or function name on the global context. Logging will
+ // be sent to dojo.debug
+ // a1:
+ // if a2 is passed, this should be an object. If not, it can be a
+ // function or function name.
+ // a2:
+ // a function name
+ var kwArgs;
+ if((arguments.length == 1)&&(typeof a1 == "object")){
+ kwArgs = a1;
+ }else{
+ kwArgs = {
+ srcObj: a1,
+ srcFunc: a2
+ };
+ }
+ kwArgs.adviceFunc = function(){
+ var argsStr = [];
+ for(var x=0; x= this.jp_.around.length){
+ return this.jp_.object[this.jp_.methodname].apply(this.jp_.object, this.args);
+ // return this.jp_.run_before_after(this.object, this.args);
+ }else{
+ var ti = this.jp_.around[this.around_index];
+ var mobj = ti[0]||dj_global;
+ var meth = ti[1];
+ return mobj[meth].call(mobj, this);
+ }
+}
+
+
+dojo.event.MethodJoinPoint = function(/*Object*/obj, /*String*/funcName){
+ this.object = obj||dj_global;
+ this.methodname = funcName;
+ this.methodfunc = this.object[funcName];
+ this.squelch = false;
+ // this.before = [];
+ // this.after = [];
+ // this.around = [];
+}
+
+dojo.event.MethodJoinPoint.getForMethod = function(/*Object*/obj, /*String*/funcName){
+ // summary:
+ // "static" class function for returning a MethodJoinPoint from a
+ // scoped function. If one doesn't exist, one is created.
+ // obj:
+ // the scope to search for the function in
+ // funcName:
+ // the name of the function to return a MethodJoinPoint for
+ if(!obj){ obj = dj_global; }
+ if(!obj[funcName]){
+ // supply a do-nothing method implementation
+ obj[funcName] = function(){};
+ if(!obj[funcName]){
+ // e.g. cannot add to inbuilt objects in IE6
+ dojo.raise("Cannot set do-nothing method on that object "+funcName);
+ }
+ }else if((!dojo.lang.isFunction(obj[funcName]))&&(!dojo.lang.isAlien(obj[funcName]))){
+ // FIXME: should we throw an exception here instead?
+ return null;
+ }
+ // we hide our joinpoint instance in obj[funcName + '$joinpoint']
+ var jpname = funcName + "$joinpoint";
+ var jpfuncname = funcName + "$joinpoint$method";
+ var joinpoint = obj[jpname];
+ if(!joinpoint){
+ var isNode = false;
+ if(dojo.event["browser"]){
+ if( (obj["attachEvent"])||
+ (obj["nodeType"])||
+ (obj["addEventListener"]) ){
+ isNode = true;
+ dojo.event.browser.addClobberNodeAttrs(obj, [jpname, jpfuncname, funcName]);
+ }
+ }
+ var origArity = obj[funcName].length;
+ obj[jpfuncname] = obj[funcName];
+ // joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, funcName);
+ joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, jpfuncname);
+ obj[funcName] = function(){
+ var args = [];
+
+ if((isNode)&&(!arguments.length)){
+ var evt = null;
+ try{
+ if(obj.ownerDocument){
+ evt = obj.ownerDocument.parentWindow.event;
+ }else if(obj.documentElement){
+ evt = obj.documentElement.ownerDocument.parentWindow.event;
+ }else if(obj.event){ //obj is a window
+ evt = obj.event;
+ }else{
+ evt = window.event;
+ }
+ }catch(e){
+ evt = window.event;
+ }
+
+ if(evt){
+ args.push(dojo.event.browser.fixEvent(evt, this));
+ }
+ }else{
+ for(var x=0; x0)){
+ // pass a cloned array, if this event disconnects this event forEach on this.before wont work
+ dojo.lang.forEach(this.before.concat(new Array()), unRollSquelch);
+ }
+
+ var result;
+ try{
+ if((this["around"])&&(this.around.length>0)){
+ var mi = new dojo.event.MethodInvocation(this, obj, args);
+ result = mi.proceed();
+ }else if(this.methodfunc){
+ result = this.object[this.methodname].apply(this.object, args);
+ }
+ }catch(e){
+ if(!this.squelch){
+ dojo.debug(e,"when calling",this.methodname,"on",this.object,"with arguments",args);
+ dojo.raise(e);
+ }
+ }
+
+ if((this["after"])&&(this.after.length>0)){
+ // see comment on this.before above
+ dojo.lang.forEach(this.after.concat(new Array()), unRollSquelch);
+ }
+
+ return (this.methodfunc) ? result : null;
+ },
+
+ getArr: function(/*String*/kind){
+ // summary: return a list of listeners of the past "kind"
+ // kind:
+ // can be one of: "before", "after", "around", "before-around", or
+ // "after-around"
+ var type = "after";
+ // FIXME: we should be able to do this through props or Array.in()
+ if((typeof kind == "string")&&(kind.indexOf("before")!=-1)){
+ type = "before";
+ }else if(kind=="around"){
+ type = "around";
+ }
+ if(!this[type]){ this[type] = []; }
+ return this[type]; // Array
+ },
+
+ kwAddAdvice: function(/*Object*/args){
+ // summary:
+ // adds advice to the joinpoint with arguments in a map
+ // args:
+ // An object that can have the following properties:
+ // - adviceType
+ // - adviceObj
+ // - adviceFunc
+ // - aroundObj
+ // - aroundFunc
+ // - once
+ // - delay
+ // - rate
+ // - adviceMsg
+ this.addAdvice( args["adviceObj"], args["adviceFunc"],
+ args["aroundObj"], args["aroundFunc"],
+ args["adviceType"], args["precedence"],
+ args["once"], args["delay"], args["rate"],
+ args["adviceMsg"]);
+ },
+
+ addAdvice: function( thisAdviceObj, thisAdvice,
+ thisAroundObj, thisAround,
+ adviceType, precedence,
+ once, delay, rate, asMessage){
+ // summary:
+ // add advice to this joinpoint using positional parameters
+ // thisAdviceObj:
+ // the scope in which to locate/execute the named adviceFunc.
+ // thisAdviceFunc:
+ // the name of the function being conected
+ // thisAroundObj:
+ // the scope in which to locate/execute the named aroundFunc.
+ // thisAroundFunc:
+ // the name of the function that will be used to mediate the
+ // advice call.
+ // adviceType:
+ // Optional. String. One of "before", "after", "around",
+ // "before-around", or "after-around". FIXME
+ // once:
+ // boolean that determines whether or not this advice will create
+ // a new connection if an identical advice set has already been
+ // provided. Defaults to "false".
+ // delay:
+ // an optional delay (in ms), as an integer, for dispatch of a
+ // listener after the source has been fired.
+ // rate:
+ // an optional rate throttling parameter (integer, in ms). When
+ // specified, this particular connection will not fire more than
+ // once in the interval specified by the rate
+ // adviceMsg:
+ // boolean. Should the listener have all the parameters passed in
+ // as a single argument?
+ var arr = this.getArr(adviceType);
+ if(!arr){
+ dojo.raise("bad this: " + this);
+ }
+
+ var ao = [thisAdviceObj, thisAdvice, thisAroundObj, thisAround, delay, rate, asMessage];
+
+ if(once){
+ if(this.hasAdvice(thisAdviceObj, thisAdvice, adviceType, arr) >= 0){
+ return;
+ }
+ }
+
+ if(precedence == "first"){
+ arr.unshift(ao);
+ }else{
+ arr.push(ao);
+ }
+ },
+
+ hasAdvice: function(thisAdviceObj, thisAdvice, adviceType, arr){
+ // summary:
+ // returns the array index of the first existing connection
+ // betweened the passed advice and this joinpoint. Will be -1 if
+ // none exists.
+ // thisAdviceObj:
+ // the scope in which to locate/execute the named adviceFunc.
+ // thisAdviceFunc:
+ // the name of the function being conected
+ // adviceType:
+ // Optional. String. One of "before", "after", "around",
+ // "before-around", or "after-around". FIXME
+ // arr:
+ // Optional. The list of advices to search. Will be found via
+ // adviceType if not passed
+ if(!arr){ arr = this.getArr(adviceType); }
+ var ind = -1;
+ for(var x=0; x 0){
+ for(var i = 0;i < dojo.flash._loadedListeners.length; i++){
+ dojo.flash._loadedListeners[i].call(null);
+ }
+ }
+ },
+
+ installing: function(){
+ // summary: Called if Flash is being installed.
+ // description:
+ // A callback to know if Flash is currently being installed or
+ // having its version revved. To be notified if Flash is installing, connect
+ // your callback to this method using the following:
+ //
+ // dojo.event.connect(dojo.flash, "installing", myInstance, "myCallback");
+
+ //dojo.debug("installing");
+ if(dojo.flash._installingListeners.length > 0){
+ for(var i = 0; i < dojo.flash._installingListeners.length; i++){
+ dojo.flash._installingListeners[i].call(null);
+ }
+ }
+ },
+
+ // Initializes dojo.flash.
+ _initialize: function(){
+ //dojo.debug("dojo.flash._initialize");
+ // see if we need to rev or install Flash on this platform
+ var installer = new dojo.flash.Install();
+ dojo.flash.installer = installer;
+
+ if(installer.needed() == true){
+ installer.install();
+ }else{
+ //dojo.debug("Writing object out");
+ // write the flash object into the page
+ dojo.flash.obj = new dojo.flash.Embed(this._visible);
+ dojo.flash.obj.write(dojo.flash.info.commVersion);
+
+ // initialize the way we do Flash/JavaScript communication
+ dojo.flash.comm = new dojo.flash.Communicator();
+ }
+ }
+};
+
+
+dojo.flash.Info = function(){
+ // summary: A class that helps us determine whether Flash is available.
+ // description:
+ // A class that helps us determine whether Flash is available,
+ // it's major and minor versions, and what Flash version features should
+ // be used for Flash/JavaScript communication. Parts of this code
+ // are adapted from the automatic Flash plugin detection code autogenerated
+ // by the Macromedia Flash 8 authoring environment.
+ //
+ // An instance of this class can be accessed on dojo.flash.info after
+ // the page is finished loading.
+ //
+ // This constructor must be called before the page is finished loading.
+
+ // Visual basic helper required to detect Flash Player ActiveX control
+ // version information on Internet Explorer
+ if(dojo.render.html.ie){
+ document.writeln('');
+
+ // hook for Internet Explorer to receive FSCommands from Flash
+ if(dojo.render.html.ie){
+ document.writeln(',
+ //which will be treated as an external javascript file in IE
+ var xscript = dojo.doc().createElement('script');
+ xscript.src = "javascript:'dojo.html.createExternalElement=function(doc, tag){ return doc.createElement(tag); }'";
+ dojo.doc().getElementsByTagName("head")[0].appendChild(xscript);
+ })();
+ }
+}else{
+ //for other browsers, simply use document.createElement
+ //is enough
+ dojo.html.createExternalElement = function(/* HTMLDocument */doc, /* string */tag){
+ // summary
+ // Creates an element in the HTML document, here for ActiveX activation workaround.
+ return doc.createElement(tag); // HTMLElement
+ }
+}
+
+dojo.html._callDeprecated = function(inFunc, replFunc, args, argName, retValue){
+ dojo.deprecated("dojo.html." + inFunc,
+ "replaced by dojo.html." + replFunc + "(" + (argName ? "node, {"+ argName + ": " + argName + "}" : "" ) + ")" + (retValue ? "." + retValue : ""), "0.5");
+ var newArgs = [];
+ if(argName){ var argsIn = {}; argsIn[argName] = args[1]; newArgs.push(args[0]); newArgs.push(argsIn); }
+ else { newArgs = args }
+ var ret = dojo.html[replFunc].apply(dojo.html, args);
+ if(retValue){ return ret[retValue]; }
+ else { return ret; }
+}
+
+dojo.html.getViewportWidth = function(){
+ return dojo.html._callDeprecated("getViewportWidth", "getViewport", arguments, null, "width");
+}
+dojo.html.getViewportHeight = function(){
+ return dojo.html._callDeprecated("getViewportHeight", "getViewport", arguments, null, "height");
+}
+dojo.html.getViewportSize = function(){
+ return dojo.html._callDeprecated("getViewportSize", "getViewport", arguments);
+}
+dojo.html.getScrollTop = function(){
+ return dojo.html._callDeprecated("getScrollTop", "getScroll", arguments, null, "top");
+}
+dojo.html.getScrollLeft = function(){
+ return dojo.html._callDeprecated("getScrollLeft", "getScroll", arguments, null, "left");
+}
+dojo.html.getScrollOffset = function(){
+ return dojo.html._callDeprecated("getScrollOffset", "getScroll", arguments, null, "offset");
+}
diff --git a/source/web/scripts/ajax/dojo/src/html/display.js b/source/web/scripts/ajax/dojo/src/html/display.js
new file mode 100644
index 0000000000..92cc49a4cd
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/html/display.js
@@ -0,0 +1,196 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.html.display");
+dojo.require("dojo.html.style");
+
+dojo.html._toggle = function(node, tester, setter){
+ node = dojo.byId(node);
+ setter(node, !tester(node));
+ return tester(node);
+}
+
+dojo.html.show = function(/* HTMLElement */node){
+ // summary
+ // Show the passed element by reverting display property set by dojo.html.hide
+ node = dojo.byId(node);
+ if(dojo.html.getStyleProperty(node, 'display')=='none'){
+ dojo.html.setStyle(node, 'display', (node.dojoDisplayCache||''));
+ node.dojoDisplayCache = undefined; // cannot use delete on a node in IE6
+ }
+}
+
+dojo.html.hide = function(/* HTMLElement */node){
+ // summary
+ // Hide the passed element by setting display:none
+ node = dojo.byId(node);
+ if(typeof node["dojoDisplayCache"] == "undefined"){ // it could == '', so we cannot say !node.dojoDisplayCount
+ var d = dojo.html.getStyleProperty(node, 'display')
+ if(d!='none'){
+ node.dojoDisplayCache = d;
+ }
+ }
+ dojo.html.setStyle(node, 'display', 'none');
+}
+
+dojo.html.setShowing = function(/* HTMLElement */node, /* boolean? */showing){
+ // summary
+ // Calls show() if showing is true, hide() otherwise
+ dojo.html[(showing ? 'show' : 'hide')](node);
+}
+
+dojo.html.isShowing = function(/* HTMLElement */node){
+ // summary
+ // Returns whether the element is displayed or not.
+ // FIXME: returns true if node is bad, isHidden would be easier to make correct
+ return (dojo.html.getStyleProperty(node, 'display') != 'none'); // boolean
+}
+
+dojo.html.toggleShowing = function(/* HTMLElement */node){
+ // summary
+ // Call setShowing() on node with the complement of isShowing(), then return the new value of isShowing()
+ return dojo.html._toggle(node, dojo.html.isShowing, dojo.html.setShowing); // boolean
+}
+
+// Simple mapping of tag names to display values
+// FIXME: simplistic
+dojo.html.displayMap = { tr: '', td: '', th: '', img: 'inline', span: 'inline', input: 'inline', button: 'inline' };
+
+dojo.html.suggestDisplayByTagName = function(/* HTMLElement */node){
+ // summary
+ // Suggest a value for the display property that will show 'node' based on it's tag
+ node = dojo.byId(node);
+ if(node && node.tagName){
+ var tag = node.tagName.toLowerCase();
+ return (tag in dojo.html.displayMap ? dojo.html.displayMap[tag] : 'block'); // string
+ }
+}
+
+dojo.html.setDisplay = function(/* HTMLElement */node, /* string */display){
+ // summary
+ // Sets the value of style.display to value of 'display' parameter if it is a string.
+ // Otherwise, if 'display' is false, set style.display to 'none'.
+ // Finally, set 'display' to a suggested display value based on the node's tag
+ dojo.html.setStyle(node, 'display', ((display instanceof String || typeof display == "string") ? display : (display ? dojo.html.suggestDisplayByTagName(node) : 'none')));
+}
+
+dojo.html.isDisplayed = function(/* HTMLElement */node){
+ // summary
+ // Is true if the the computed display style for node is not 'none'
+ // FIXME: returns true if node is bad, isNotDisplayed would be easier to make correct
+ return (dojo.html.getComputedStyle(node, 'display') != 'none'); // boolean
+}
+
+dojo.html.toggleDisplay = function(/* HTMLElement */node){
+ // summary
+ // Call setDisplay() on node with the complement of isDisplayed(), then
+ // return the new value of isDisplayed()
+ return dojo.html._toggle(node, dojo.html.isDisplayed, dojo.html.setDisplay); // boolean
+}
+
+dojo.html.setVisibility = function(/* HTMLElement */node, /* string */visibility){
+ // summary
+ // Sets the value of style.visibility to value of 'visibility' parameter if it is a string.
+ // Otherwise, if 'visibility' is false, set style.visibility to 'hidden'. Finally, set style.visibility to 'visible'.
+ dojo.html.setStyle(node, 'visibility', ((visibility instanceof String || typeof visibility == "string") ? visibility : (visibility ? 'visible' : 'hidden')));
+}
+
+dojo.html.isVisible = function(/* HTMLElement */node){
+ // summary
+ // Returns true if the the computed visibility style for node is not 'hidden'
+ // FIXME: returns true if node is bad, isInvisible would be easier to make correct
+ return (dojo.html.getComputedStyle(node, 'visibility') != 'hidden'); // boolean
+}
+
+dojo.html.toggleVisibility = function(node){
+ // summary
+ // Call setVisibility() on node with the complement of isVisible(), then return the new value of isVisible()
+ return dojo.html._toggle(node, dojo.html.isVisible, dojo.html.setVisibility); // boolean
+}
+
+dojo.html.setOpacity = function(/* HTMLElement */node, /* float */opacity, /* boolean? */dontFixOpacity){
+ // summary
+ // Sets the opacity of node in a cross-browser way.
+ // float between 0.0 (transparent) and 1.0 (opaque)
+ node = dojo.byId(node);
+ var h = dojo.render.html;
+ if(!dontFixOpacity){
+ if( opacity >= 1.0){
+ if(h.ie){
+ dojo.html.clearOpacity(node);
+ return;
+ }else{
+ opacity = 0.999999;
+ }
+ }else if( opacity < 0.0){ opacity = 0; }
+ }
+ if(h.ie){
+ if(node.nodeName.toLowerCase() == "tr"){
+ // FIXME: is this too naive? will we get more than we want?
+ var tds = node.getElementsByTagName("td");
+ for(var x=0; x= 0.999999 ? 1.0 : Number(opac); // float
+}
diff --git a/source/web/scripts/ajax/dojo/src/html/iframe.js b/source/web/scripts/ajax/dojo/src/html/iframe.js
new file mode 100644
index 0000000000..716cefb3e6
--- /dev/null
+++ b/source/web/scripts/ajax/dojo/src/html/iframe.js
@@ -0,0 +1,128 @@
+/*
+ Copyright (c) 2004-2006, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+*/
+
+dojo.provide("dojo.html.iframe");
+dojo.require("dojo.html.util");
+
+// thanks burstlib!
+dojo.html.iframeContentWindow = function(/* HTMLIFrameElement */iframe_el) {
+ // summary
+ // returns the window reference of the passed iframe
+ var win = dojo.html.getDocumentWindow(dojo.html.iframeContentDocument(iframe_el)) ||
+ // Moz. TODO: is this available when defaultView isn't?
+ dojo.html.iframeContentDocument(iframe_el).__parent__ ||
+ (iframe_el.name && document.frames[iframe_el.name]) || null;
+ return win; // Window
+}
+
+dojo.html.iframeContentDocument = function(/* HTMLIFrameElement */iframe_el){
+ // summary
+ // returns a reference to the document object inside iframe_el
+ var doc = iframe_el.contentDocument // W3
+ || ((iframe_el.contentWindow)&&(iframe_el.contentWindow.document)) // IE
+ || ((iframe_el.name)&&(document.frames[iframe_el.name])&&(document.frames[iframe_el.name].document))
+ || null;
+ return doc; // HTMLDocument
+}
+
+dojo.html.BackgroundIframe = function(/* HTMLElement */node) {
+ // summary
+ // For IE z-index schenanigans
+ // Two possible uses:
+ // 1. new dojo.html.BackgroundIframe(node)
+ // Makes a background iframe as a child of node, that fills area (and position) of node
+ // 2. new dojo.html.BackgroundIframe()
+ // Attaches frame to dojo.body(). User must call size() to set size.
+ if(dojo.render.html.ie55 || dojo.render.html.ie60) {
+ var html=""
+ }else{
+ this.rcvNode = dojo.io.createIFrame(this.rcvNodeName, "", initUrl);
+ // dojo.io.setIFrameSrc(this.rcvNode, initUrl);
+ // we're still waiting on the iframe to call back up to use and
+ // advertise that it's been initialized via tunnelInit
+ }
+ }
+}
+
+cometd.mimeReplaceTransport = new function(){
+ this.connected = false;
+ this.connectionId = null;
+ this.xhr = null;
+
+ this.authToken = null;
+ this.lastTimestamp = null;
+ this.lastId = null;
+ this.backlog = [];
+
+ this.check = function(types, version, xdomain){
+ return ((!xdomain)&&
+ (dojo.render.html.mozilla)&& // seems only Moz really supports this right now = (
+ (dojo.lang.inArray(types, "mime-message-block")));
+ }
+
+ this.tunnelInit = function(){
+ if(this.connected){ return; }
+ // FIXME: open up the connection here
+ this.openTunnelWith({
+ message: dojo.json.serialize([
+ {
+ channel: "/meta/connect",
+ clientId: cometd.clientId,
+ connectionType: "mime-message-block"
+ // FIXME: auth not passed here!
+ // "authToken": this.authToken
+ }
+ ])
+ });
+ this.connected = true;
+ }
+
+ this.tunnelCollapse = function(){
+ if(this.connected){
+ // try to restart the tunnel
+ this.connected = false;
+ this.openTunnelWith({
+ message: dojo.json.serialize([
+ {
+ channel: "/meta/reconnect",
+ clientId: cometd.clientId,
+ connectionId: this.connectionId,
+ timestamp: this.lastTimestamp,
+ id: this.lastId
+ // FIXME: no authToken provision!
+ }
+ ])
+ });
+ }
+ }
+
+ this.deliver = cometd.iframeTransport.deliver;
+ // the logic appears to be the same
+
+ this.handleOnLoad = function(resp){
+ cometd.deliver(dojo.json.evalJson(this.xhr.responseText));
+ }
+
+ this.openTunnelWith = function(content, url){
+ // set up the XHR object and register the multipart callbacks
+ this.xhr = dojo.hostenv.getXmlhttpObject();
+ this.xhr.multipart = true; // FIXME: do Opera and Safari support this flag?
+ if(dojo.render.html.mozilla){
+ this.xhr.addEventListener("load", dojo.lang.hitch(this, "handleOnLoad"), false);
+ }else if(dojo.render.html.safari){
+ // Blah. WebKit doesn't actually populate responseText and/or responseXML. Useless.
+ dojo.debug("Webkit is broken with multipart responses over XHR = (");
+ this.xhr.onreadystatechange = dojo.lang.hitch(this, "handleOnLoad");
+ }else{
+ this.xhr.onload = dojo.lang.hitch(this, "handleOnLoad");
+ }
+ this.xhr.open("POST", (url||cometd.url), true); // async post
+ this.xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+ dojo.debug(dojo.json.serialize(content));
+ this.xhr.send(dojo.io.argsFromMap(content, "utf8"));
+ }
+
+ this.processBacklog = function(){
+ while(this.backlog.length > 0){
+ this.sendMessage(this.backlog.shift(), true);
+ }
+ }
+
+ this.sendMessage = function(message, bypassBacklog){
+ // FIXME: what about auth fields?
+ if((bypassBacklog)||(this.connected)){
+ message.connectionId = this.connectionId;
+ message.clientId = cometd.clientId;
+ var bindArgs = {
+ url: cometd.url||djConfig["cometdRoot"],
+ method: "POST",
+ mimetype: "text/json",
+ content: { message: dojo.json.serialize([ message ]) }
+ };
+ return dojo.io.bind(bindArgs);
+ }else{
+ this.backlog.push(message);
+ }
+ }
+
+ this.startup = function(handshakeData){
+ dojo.debugShallow(handshakeData);
+ if(this.connected){ return; }
+ this.tunnelInit();
+ }
+}
+
+cometd.longPollTransport = new function(){
+ this.connected = false;
+ this.connectionId = null;
+
+ this.authToken = null;
+ this.lastTimestamp = null;
+ this.lastId = null;
+ this.backlog = [];
+
+ this.check = function(types, version, xdomain){
+ return ((!xdomain)&&(dojo.lang.inArray(types, "long-polling")));
+ }
+
+ this.tunnelInit = function(){
+ if(this.connected){ return; }
+ // FIXME: open up the connection here
+ this.openTunnelWith({
+ message: dojo.json.serialize([
+ {
+ channel: "/meta/connect",
+ clientId: cometd.clientId,
+ connectionType: "long-polling"
+ // FIXME: auth not passed here!
+ // "authToken": this.authToken
+ }
+ ])
+ });
+ this.connected = true;
+ }
+
+ this.tunnelCollapse = function(){
+ if(!this.connected){
+ // try to restart the tunnel
+ this.connected = false;
+ dojo.debug("clientId:", cometd.clientId);
+ this.openTunnelWith({
+ message: dojo.json.serialize([
+ {
+ channel: "/meta/reconnect",
+ connectionType: "long-polling",
+ clientId: cometd.clientId,
+ connectionId: this.connectionId,
+ timestamp: this.lastTimestamp,
+ id: this.lastId
+ // FIXME: no authToken provision!
+ }
+ ])
+ });
+ }
+ }
+
+ this.deliver = cometd.iframeTransport.deliver;
+ // the logic appears to be the same
+
+ this.openTunnelWith = function(content, url){
+ dojo.io.bind({
+ url: (url||cometd.url),
+ method: "post",
+ content: content,
+ mimetype: "text/json",
+ load: dojo.lang.hitch(this, function(type, data, evt, args){
+ // dojo.debug(evt.responseText);
+ cometd.deliver(data);
+ this.connected = false;
+ this.tunnelCollapse();
+ }),
+ error: function(){ dojo.debug("tunnel opening failed"); }
+ });
+ this.connected = true;
+ }
+
+ this.processBacklog = function(){
+ while(this.backlog.length > 0){
+ this.sendMessage(this.backlog.shift(), true);
+ }
+ }
+
+ this.sendMessage = function(message, bypassBacklog){
+ // FIXME: what about auth fields?
+ if((bypassBacklog)||(this.connected)){
+ message.connectionId = this.connectionId;
+ message.clientId = cometd.clientId;
+ var bindArgs = {
+ url: cometd.url||djConfig["cometdRoot"],
+ method: "post",
+ mimetype: "text/json",
+ content: { message: dojo.json.serialize([ message ]) }
+ };
+ return dojo.io.bind(bindArgs);
+ }else{
+ this.backlog.push(message);
+ }
+ }
+
+ this.startup = function(handshakeData){
+ if(this.connected){ return; }
+ this.tunnelInit();
+ }
+}
+
+cometd.callbackPollTransport = new function(){
+ this.connected = false;
+ this.connectionId = null;
+
+ this.authToken = null;
+ this.lastTimestamp = null;
+ this.lastId = null;
+ this.backlog = [];
+
+ this.check = function(types, version, xdomain){
+ // we handle x-domain!
+ return dojo.lang.inArray(types, "callback-polling");
+ }
+
+ this.tunnelInit = function(){
+ if(this.connected){ return; }
+ // FIXME: open up the connection here
+ this.openTunnelWith({
+ message: dojo.json.serialize([
+ {
+ channel: "/meta/connect",
+ clientId: cometd.clientId,
+ connectionType: "callback-polling"
+ // FIXME: auth not passed here!
+ // "authToken": this.authToken
+ }
+ ])
+ });
+ this.connected = true;
+ }
+
+ this.tunnelCollapse = function(){
+ if(!this.connected){
+ // try to restart the tunnel
+ this.connected = false;
+ this.openTunnelWith({
+ message: dojo.json.serialize([
+ {
+ channel: "/meta/reconnect",
+ connectionType: "long-polling",
+ clientId: cometd.clientId,
+ connectionId: this.connectionId,
+ timestamp: this.lastTimestamp,
+ id: this.lastId
+ // FIXME: no authToken provision!
+ }
+ ])
+ });
+ }
+ }
+
+ this.deliver = cometd.iframeTransport.deliver;
+ // the logic appears to be the same
+
+ this.openTunnelWith = function(content, url){
+ // create a
+
+
+ The Dojo Toolkit -- xip_client.html
+
+ This file is used for Dojo's XMLHttpRequest Iframe Proxy. This is the "client" file used
+ internally by dojo.io.XhrIframeProxy.
+
+
+
+