svn commit: r509273 [24/50] - in /ofbiz/trunk/framework/images/
Locked
svn commit: r509273 [24/50] - in /ofbiz/trunk/framework/images/
 
|
Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/array.js
URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/array.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/array.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/array.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,284 @@ +/* + 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.lang.array"); + +dojo.require("dojo.lang.common"); + +// FIXME: Is this worthless since you can do: if(name in obj) +// is this the right place for this? + +dojo.lang.mixin(dojo.lang, { + has: function(/*Object*/obj, /*String*/name){ + // summary: is there a property with the passed name in obj? + try{ + return typeof obj[name] != "undefined"; // Boolean + }catch(e){ return false; } // Boolean + }, + + isEmpty: function(/*Object*/obj){ + // summary: + // can be used to determine if the passed object is "empty". In + // the case of array-like objects, the length, property is + // examined, but for other types of objects iteration is used to + // examine the iterable "surface area" to determine if any + // non-prototypal properties have been assigned. This iteration is + // prototype-extension safe. + if(dojo.lang.isObject(obj)){ + var tmp = {}; + var count = 0; + for(var x in obj){ + if(obj[x] && (!tmp[x])){ + count++; + break; + } + } + return count == 0; // boolean + }else if(dojo.lang.isArrayLike(obj) || dojo.lang.isString(obj)){ + return obj.length == 0; // boolean + } + }, + + map: function(/*Array*/arr, /*Object|Function*/obj, /*Function?*/unary_func){ + // summary: + // returns a new array constituded from the return values of + // passing each element of arr into unary_func. The obj parameter + // may be passed to enable the passed function to be called in + // that scope. In environments that support JavaScript 1.6, this + // function is a passthrough to the built-in map() function + // provided by Array instances. For details on this, see: + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:map + // examples: + // dojo.lang.map([1, 2, 3, 4], function(item){ return item+1 }); + // // returns [2, 3, 4, 5] + var isString = dojo.lang.isString(arr); + if(isString){ + // arr: String + arr = arr.split(""); + } + if(dojo.lang.isFunction(obj)&&(!unary_func)){ + unary_func = obj; + obj = dj_global; + }else if(dojo.lang.isFunction(obj) && unary_func){ + // ff 1.5 compat + var tmpObj = obj; + obj = unary_func; + unary_func = tmpObj; + } + if(Array.map){ + var outArr = Array.map(arr, unary_func, obj); + }else{ + var outArr = []; + for(var i=0;i<arr.length;++i){ + outArr.push(unary_func.call(obj, arr[i])); + } + } + if(isString) { + return outArr.join(""); // String + } else { + return outArr; // Array + } + }, + + reduce: function(/*Array*/arr, initialValue, /*Object|Function*/obj, /*Function*/binary_func){ + // summary: + // similar to Python's builtin reduce() function. The result of + // the previous computation is passed as the first argument to + // binary_func along with the next value from arr. The result of + // this call is used along with the subsequent value from arr, and + // this continues until arr is exhausted. The return value is the + // last result. The "obj" and "initialValue" parameters may be + // safely omitted and the order of obj and binary_func may be + // reversed. The default order of the obj and binary_func argument + // will probably be reversed in a future release, and this call + // order is supported today. + // examples: + // dojo.lang.reduce([1, 2, 3, 4], function(last, next){ return last+next}); + // returns 10 + var reducedValue = initialValue; + if(arguments.length == 1){ + dojo.debug("dojo.lang.reduce called with too few arguments!"); + return false; + }else if(arguments.length == 2){ + binary_func = initialValue; + reducedValue = arr.shift(); + }else if(arguments.lenght == 3){ + if(dojo.lang.isFunction(obj)){ + binary_func = obj; + obj = null; + } + }else{ + // un-fsck the default order + // FIXME: + // could be wrong for some strange function object cases. Not + // sure how to test for them. + if(dojo.lang.isFunction(obj)){ + var tmp = binary_func; + binary_func = obj; + obj = tmp; + } + } + + var ob = obj ? obj : dj_global; + dojo.lang.map(arr, + function(val){ + reducedValue = binary_func.call(ob, reducedValue, val); + } + ); + return reducedValue; + }, + + forEach: function(/*Array*/anArray, /*Function*/callback, /*Object?*/thisObject){ + // summary: + // for every item in anArray, call callback with that item as its + // only parameter. Return values are ignored. This funciton + // corresponds (and wraps) the JavaScript 1.6 forEach method. For + // more details, see: + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:forEach + if(dojo.lang.isString(anArray)){ + // anArray: String + anArray = anArray.split(""); + } + if(Array.forEach){ + Array.forEach(anArray, callback, thisObject); + }else{ + // FIXME: there are several ways of handilng thisObject. Is dj_global always the default context? + if(!thisObject){ + thisObject=dj_global; + } + for(var i=0,l=anArray.length; i<l; i++){ + callback.call(thisObject, anArray[i], i, anArray); + } + } + }, + + _everyOrSome: function(/*Boolean*/every, /*Array*/arr, /*Function*/callback, /*Object?*/thisObject){ + if(dojo.lang.isString(arr)){ + //arr: String + arr = arr.split(""); + } + if(Array.every){ + return Array[ every ? "every" : "some" ](arr, callback, thisObject); + }else{ + if(!thisObject){ + thisObject = dj_global; + } + for(var i=0,l=arr.length; i<l; i++){ + var result = callback.call(thisObject, arr[i], i, arr); + if(every && !result){ + return false; // Boolean + }else if((!every)&&(result)){ + return true; // Boolean + } + } + return Boolean(every); // Boolean + } + }, + + every: function(/*Array*/arr, /*Function*/callback, /*Object?*/thisObject){ + // summary: + // determines whether or not every item in the array satisfies the + // condition implemented by callback. thisObject may be used to + // scope the call to callback. The function signature is derived + // from the JavaScript 1.6 Array.every() function. More + // information on this can be found here: + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every + // examples: + // dojo.lang.every([1, 2, 3, 4], function(item){ return item>1; }); + // // returns false + // dojo.lang.every([1, 2, 3, 4], function(item){ return item>0; }); + // // returns true + return this._everyOrSome(true, arr, callback, thisObject); // Boolean + }, + + some: function(/*Array*/arr, /*Function*/callback, /*Object?*/thisObject){ + // summary: + // determines whether or not any item in the array satisfies the + // condition implemented by callback. thisObject may be used to + // scope the call to callback. The function signature is derived + // from the JavaScript 1.6 Array.some() function. More + // information on this can be found here: + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some + // examples: + // dojo.lang.some([1, 2, 3, 4], function(item){ return item>1; }); + // // returns true + // dojo.lang.some([1, 2, 3, 4], function(item){ return item<1; }); + // // returns false + return this._everyOrSome(false, arr, callback, thisObject); // Boolean + }, + + filter: function(/*Array*/arr, /*Function*/callback, /*Object?*/thisObject){ + // summary: + // returns a new Array with those items from arr that match the + // condition implemented by callback.thisObject may be used to + // scope the call to callback. The function signature is derived + // from the JavaScript 1.6 Array.filter() function, although + // special accomidation is made in our implementation for strings. + // More information on the JS 1.6 API can be found here: + // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:filter + // examples: + // dojo.lang.some([1, 2, 3, 4], function(item){ return item>1; }); + // // returns [2, 3, 4] + var isString = dojo.lang.isString(arr); + if(isString){ /*arr: String*/arr = arr.split(""); } + var outArr; + if(Array.filter){ + outArr = Array.filter(arr, callback, thisObject); + }else{ + if(!thisObject){ + if(arguments.length >= 3){ dojo.raise("thisObject doesn't exist!"); } + thisObject = dj_global; + } + + outArr = []; + for(var i = 0; i < arr.length; i++){ + if(callback.call(thisObject, arr[i], i, arr)){ + outArr.push(arr[i]); + } + } + } + if(isString){ + return outArr.join(""); // String + } else { + return outArr; // Array + } + }, + + unnest: function(/* ... */){ + // summary: + // Creates a 1-D array out of all the arguments passed, + // unravelling any array-like objects in the process + // usage: + // unnest(1, 2, 3) ==> [1, 2, 3] + // unnest(1, [2, [3], [[[4]]]]) ==> [1, 2, 3, 4] + + var out = []; + for(var i = 0; i < arguments.length; i++){ + if(dojo.lang.isArrayLike(arguments[i])){ + var add = dojo.lang.unnest.apply(this, arguments[i]); + out = out.concat(add); + }else{ + out.push(arguments[i]); + } + } + return out; // Array + }, + + toArray: function(/*Object*/arrayLike, /*Number*/startOffset){ + // summary: + // Converts an array-like object (i.e. arguments, DOMCollection) + // to an array. Returns a new Array object. + var array = []; + for(var i = startOffset||0; i < arrayLike.length; i++){ + array.push(arrayLike[i]); + } + return array; // Array + } +}); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/array.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/array.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/array.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/assert.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/assert.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/assert.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/assert.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,116 @@ +/* + 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.lang.assert"); + +dojo.require("dojo.lang.common"); +dojo.require("dojo.lang.array"); +dojo.require("dojo.lang.type"); + +dojo.lang.assert = function(/* boolean */ booleanValue, /* string? */ message){ + /* summary: + * Throws an exception if the assertion fails. + * description: + * If the asserted condition is true, this method does nothing. If the + * condition is false, we throw an error with a error message. + * booleanValue: Must be true for the assertion to succeed. + * message: A string describing the assertion. + */ + + // throws: Throws an Error if 'booleanValue' is false. + if(!booleanValue){ + var errorMessage = "An assert statement failed.\n" + + "The method dojo.lang.assert() was called with a 'false' value.\n"; + if(message){ + errorMessage += "Here's the assert message:\n" + message + "\n"; + } + // Use throw instead of dojo.raise, until bug #264 is fixed: + // dojo.raise(errorMessage); + throw new Error(errorMessage); + } +} + +dojo.lang.assertType = function(/* anything */ value, /* misc. */ type, /* object? */ keywordParameters){ + /* summary: + * Throws an exception if 'value' is not of type 'type' + * description: + * Given a value and a data type, this method checks the type of the value + * to make sure it matches the data type, and throws an exception if there + * is a mismatch. + * value: Any literal value or object instance. + * type: A class of object, or a literal type, or the string name of a type, or an array with a list of types. + * keywordParameters: {optional: boolean} + */ + + /* examples: + * dojo.lang.assertType("foo", String); + * dojo.lang.assertType(12345, Number); + * dojo.lang.assertType(false, Boolean); + * dojo.lang.assertType([6, 8], Array); + * dojo.lang.assertType(dojo.lang.assertType, Function); + * dojo.lang.assertType({foo: "bar"}, Object); + * dojo.lang.assertType(new Date(), Date); + * dojo.lang.assertType(null, Array, {optional: true}); + * throws: Throws an Error if 'value' is not of type 'type'. + */ + if (dojo.lang.isString(keywordParameters)) { + dojo.deprecated('dojo.lang.assertType(value, type, "message")', 'use dojo.lang.assertType(value, type) instead', "0.5"); + } + if(!dojo.lang.isOfType(value, type, keywordParameters)){ + if(!dojo.lang.assertType._errorMessage){ + dojo.lang.assertType._errorMessage = "Type mismatch: dojo.lang.assertType() failed."; + } + dojo.lang.assert(false, dojo.lang.assertType._errorMessage); + } +} + +dojo.lang.assertValidKeywords = function(/* object */ object, /* array */ expectedProperties, /* string? */ message){ + /* summary: + * Throws an exception 'object' has any properties other than the 'expectedProperties'. + * description: + * Given an anonymous object and a list of expected property names, this + * method check to make sure the object does not have any properties + * that aren't on the list of expected properties, and throws an Error + * if there are unexpected properties. This is useful for doing error + * checking on keyword arguments, to make sure there aren't typos. + * object: An anonymous object. + * expectedProperties: An array of strings (or an object with all the expected properties). + * message: A message describing the assertion. + */ + + /* examples: + * dojo.lang.assertValidKeywords({a: 1, b: 2}, ["a", "b"]); + * dojo.lang.assertValidKeywords({a: 1, b: 2}, ["a", "b", "c"]); + * dojo.lang.assertValidKeywords({foo: "iggy"}, ["foo"]); + * dojo.lang.assertValidKeywords({foo: "iggy"}, ["foo", "bar"]); + * dojo.lang.assertValidKeywords({foo: "iggy"}, {foo: null, bar: null}); + * throws: Throws an Error if 'object' has unexpected properties. + */ + var key; + if(!message){ + if(!dojo.lang.assertValidKeywords._errorMessage){ + dojo.lang.assertValidKeywords._errorMessage = "In dojo.lang.assertValidKeywords(), found invalid keyword:"; + } + message = dojo.lang.assertValidKeywords._errorMessage; + } + if(dojo.lang.isArray(expectedProperties)){ + for(key in object){ + if(!dojo.lang.inArray(expectedProperties, key)){ + dojo.lang.assert(false, message + " " + key); + } + } + }else{ + for(key in object){ + if(!(key in expectedProperties)){ + dojo.lang.assert(false, message + " " + key); + } + } + } +} Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/assert.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/assert.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/assert.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/common.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/common.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/common.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/common.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,253 @@ +/* + 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.lang.common"); + +dojo.lang.inherits = function(/*Function*/subclass, /*Function*/superclass){ + // summary: Set up inheritance between two classes. + if(!dojo.lang.isFunction(superclass)){ + dojo.raise("dojo.inherits: superclass argument ["+superclass+"] must be a function (subclass: ["+subclass+"']"); + } + subclass.prototype = new superclass(); + subclass.prototype.constructor = subclass; + subclass.superclass = superclass.prototype; + // DEPRECATED: super is a reserved word, use 'superclass' + subclass['super'] = superclass.prototype; +} + +dojo.lang._mixin = function(/*Object*/ obj, /*Object*/ props){ + // summary: + // Adds all properties and methods of props to obj. This addition is + // "prototype extension safe", so that instances of objects will not + // pass along prototype defaults. + var tobj = {}; + for(var x in props){ + // the "tobj" condition avoid copying properties in "props" + // inherited from Object.prototype. For example, if obj has a custom + // toString() method, don't overwrite it with the toString() method + // that props inherited from Object.protoype + if((typeof tobj[x] == "undefined") || (tobj[x] != props[x])){ + obj[x] = props[x]; + } + } + // IE doesn't recognize custom toStrings in for..in + if(dojo.render.html.ie + && (typeof(props["toString"]) == "function") + && (props["toString"] != obj["toString"]) + && (props["toString"] != tobj["toString"])) + { + obj.toString = props.toString; + } + return obj; // Object +} + +dojo.lang.mixin = function(/*Object*/obj, /*Object...*/props){ + // summary: Adds all properties and methods of props to obj. + for(var i=1, l=arguments.length; i<l; i++){ + dojo.lang._mixin(obj, arguments[i]); + } + return obj; // Object +} + +dojo.lang.extend = function(/*Object*/ constructor, /*Object...*/ props){ + // summary: + // Adds all properties and methods of props to constructor's + // prototype, making them available to all instances created with + // constructor. + for(var i=1, l=arguments.length; i<l; i++){ + dojo.lang._mixin(constructor.prototype, arguments[i]); + } + return constructor; // Object +} + +// Promote to dojo module +dojo.inherits = dojo.lang.inherits; +//dojo.lang._mixin = dojo.lang._mixin; +dojo.mixin = dojo.lang.mixin; +dojo.extend = dojo.lang.extend; + +dojo.lang.find = function( /*Array*/ array, + /*Object*/ value, + /*Boolean?*/ identity, + /*Boolean?*/ findLast){ + // summary: + // Return the index of value in array, returning -1 if not found. + // array: just what you think + // value: the value to locate + // identity: + // If true, matches with identity comparison (===). If false, uses + // normal comparison (==). + // findLast: + // If true, returns index of last instance of value. + // examples: + // find(array, value[, identity [findLast]]) // recommended + // find(value, array[, identity [findLast]]) // deprecated + + // support both (array, value) and (value, array) + if(!dojo.lang.isArrayLike(array) && dojo.lang.isArrayLike(value)) { + dojo.deprecated('dojo.lang.find(value, array)', 'use dojo.lang.find(array, value) instead', "0.5"); + var temp = array; + array = value; + value = temp; + } + var isString = dojo.lang.isString(array); + if(isString) { array = array.split(""); } + + if(findLast) { + var step = -1; + var i = array.length - 1; + var end = -1; + } else { + var step = 1; + var i = 0; + var end = array.length; + } + if(identity){ + while(i != end) { + if(array[i] === value){ return i; } + i += step; + } + }else{ + while(i != end) { + if(array[i] == value){ return i; } + i += step; + } + } + return -1; // number +} + +dojo.lang.indexOf = dojo.lang.find; + +dojo.lang.findLast = function(/*Array*/array, /*Object*/value, /*boolean?*/identity){ + // summary: + // Return index of last occurance of value in array, returning -1 if + // not found. This is a shortcut for dojo.lang.find() with a true + // value for its "findLast" parameter. + // identity: + // If true, matches with identity comparison (===). If false, uses + // normal comparison (==). + return dojo.lang.find(array, value, identity, true); // number +} + +dojo.lang.lastIndexOf = dojo.lang.findLast; + +dojo.lang.inArray = function(array /*Array*/, value /*Object*/){ + // summary: Return true if value is present in array. + return dojo.lang.find(array, value) > -1; // boolean +} + +/** + * Partial implmentation of is* functions from + * http://www.crockford.com/javascript/recommend.html + * NOTE: some of these may not be the best thing to use in all situations + * as they aren't part of core JS and therefore can't work in every case. + * See WARNING messages inline for tips. + * + * The following is* functions are fairly "safe" + */ + +dojo.lang.isObject = function(/*anything*/ it){ + // summary: Return true if it is an Object, Array or Function. + if(typeof it == "undefined"){ return false; } + return (typeof it == "object" || it === null || dojo.lang.isArray(it) || dojo.lang.isFunction(it)); // Boolean +} + +dojo.lang.isArray = function(/*anything*/ it){ + // summary: Return true if it is an Array. + return (it && it instanceof Array || typeof it == "array"); // Boolean +} + +dojo.lang.isArrayLike = function(/*anything*/ it){ + // summary: + // Return true if it can be used as an array (i.e. is an object with + // an integer length property). + if((!it)||(dojo.lang.isUndefined(it))){ return false; } + if(dojo.lang.isString(it)){ return false; } + if(dojo.lang.isFunction(it)){ return false; } // keeps out built-in constructors (Number, String, ...) which have length properties + if(dojo.lang.isArray(it)){ return true; } + // form node itself is ArrayLike, but not always iterable. Use form.elements instead. + if((it.tagName)&&(it.tagName.toLowerCase()=='form')){ return false; } + if(dojo.lang.isNumber(it.length) && isFinite(it.length)){ return true; } + return false; // Boolean +} + +dojo.lang.isFunction = function(/*anything*/ it){ + // summary: Return true if it is a Function. + return (it instanceof Function || typeof it == "function"); // Boolean +}; + +(function(){ + // webkit treats NodeList as a function, which is bad + if((dojo.render.html.capable)&&(dojo.render.html["safari"])){ + dojo.lang.isFunction = function(/*anything*/ it){ + if((typeof(it) == "function") && (it == "[object NodeList]")) { return false; } + return (it instanceof Function || typeof it == "function"); // Boolean + } + } +})(); + +dojo.lang.isString = function(/*anything*/ it){ + // summary: Return true if it is a String. + return (typeof it == "string" || it instanceof String); +} + +dojo.lang.isAlien = function(/*anything*/ it){ + // summary: Return true if it is not a built-in function. False if not. + if(!it){ return false; } + return !dojo.lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean +} + +dojo.lang.isBoolean = function(/*anything*/ it){ + // summary: Return true if it is a Boolean. + return (it instanceof Boolean || typeof it == "boolean"); // Boolean +} + +/** + * The following is***() functions are somewhat "unsafe". Fortunately, + * there are workarounds the the language provides and are mentioned + * in the WARNING messages. + * + */ +dojo.lang.isNumber = function(/*anything*/ it){ + // summary: Return true if it is a number. + // description: + // WARNING - In most cases, isNaN(it) is sufficient to determine whether or not + // something is a number or can be used as such. For example, a number or string + // can be used interchangably when accessing array items (array["1"] is the same as + // array[1]) and isNaN will return false for both values ("1" and 1). However, + // isNumber("1") will return false, which is generally not too useful. + // Also, isNumber(NaN) returns true, again, this isn't generally useful, but there + // are corner cases (like when you want to make sure that two things are really + // the same type of thing). That is really where isNumber "shines". + // + // Recommendation - Use isNaN(it) when possible + + return (it instanceof Number || typeof it == "number"); // Boolean +} + +/* + * FIXME: Should isUndefined go away since it is error prone? + */ +dojo.lang.isUndefined = function(/*anything*/ it){ + // summary: Return true if it is not defined. + // description: + // WARNING - In some cases, isUndefined will not behave as you + // might expect. If you do isUndefined(foo) and there is no earlier + // reference to foo, an error will be thrown before isUndefined is + // called. It behaves correctly if you scope yor object first, i.e. + // isUndefined(foo.bar) where foo is an object and bar isn't a + // property of the object. + // + // Recommendation - Use typeof foo == "undefined" when possible + + return ((typeof(it) == "undefined")&&(it == undefined)); // Boolean +} + +// end Crockford functions Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/common.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/common.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/common.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/declare.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/declare.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/declare.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/declare.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,168 @@ +/* + 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.lang.declare"); + +dojo.require("dojo.lang.common"); +dojo.require("dojo.lang.extras"); + +dojo.lang.declare = function( /*String*/ className, + /*Function|Array*/ superclass, + /*Function?*/ init, + /*Object|Array*/ props){ + /* + * summary: Create a feature-rich constructor with a compact notation + * className: the name of the constructor (loosely, a "class") + * superclass: + * may be a Function, or an Array of Functions. If "superclass" is an + * array, the first element is used as the prototypical ancestor and + * any following Functions become mixin ancestors. + * init: an initializer function + * props: + * an object (or array of objects) whose properties are copied to the + * created prototype + * description: + * Create a constructor using a compact notation for inheritance and + * prototype extension. "superclass" argument may be a Function, or an + * array of Functions. + * + * If "superclass" is an array, the first element is used as the + * prototypical ancestor and any following Functions become mixin + * ancestors. + * + * All "superclass(es)" must be Functions (not mere Objects). + * + * Using mixin ancestors provides a type of multiple inheritance. + * Mixin ancestors prototypical properties are copied to the subclass, + * and any inializater/constructor is invoked. + * + * Properties of object "props" are copied to the constructor + * prototype. If "props" is an array, properties of each object in the + * array are copied to the constructor prototype. + * + * name of the class ("className" argument) is stored in + * "declaredClass" property + * + * Initializer functions are called when an object is instantiated + * from this constructor. + * + * Aliased as "dojo.declare" + * + * Usage: + * + * dojo.declare("my.classes.bar", my.classes.foo, + * function(){ + * // initialization function + * this.myComplicatedObject = new ReallyComplicatedObject(); + * }, + * { // properties to be added to the class prototype + * someValue: 2, + * someMethod: function(){ + * doStuff(); + * } + * } + * ); + * + */ + if((dojo.lang.isFunction(props))||((!props)&&(!dojo.lang.isFunction(init)))){ + // parameter juggling to support omitting init param (also allows + // reordering init and props arguments) + var temp = props; + props = init; + init = temp; + } + var mixins = [ ]; + if(dojo.lang.isArray(superclass)){ + mixins = superclass; + superclass = mixins.shift(); + } + if(!init){ + init = dojo.evalObjPath(className, false); + if((init)&&(!dojo.lang.isFunction(init))){ init = null }; + } + var ctor = dojo.lang.declare._makeConstructor(); + var scp = (superclass ? superclass.prototype : null); + if(scp){ + scp.prototyping = true; + ctor.prototype = new superclass(); + scp.prototyping = false; + } + ctor.superclass = scp; + ctor.mixins = mixins; + for(var i=0,l=mixins.length; i<l; i++){ + dojo.lang.extend(ctor, mixins[i].prototype); + } + ctor.prototype.initializer = null; + ctor.prototype.declaredClass = className; + if(dojo.lang.isArray(props)){ + dojo.lang.extend.apply(dojo.lang, [ctor].concat(props)); + }else{ + dojo.lang.extend(ctor, (props)||{}); + } + dojo.lang.extend(ctor, dojo.lang.declare._common); + ctor.prototype.constructor = ctor; + ctor.prototype.initializer = (ctor.prototype.initializer)||(init)||(function(){}); + var created = dojo.parseObjPath(className, null, true); + created.obj[created.prop] = ctor; + return ctor; // Function +} + +dojo.lang.declare._makeConstructor = function(){ + return function(){ + // get the generational context (which object [or prototype] should be constructed) + var self = this._getPropContext(); + var s = self.constructor.superclass; + if((s)&&(s.constructor)){ + if(s.constructor==arguments.callee){ + // if this constructor is invoked directly (my.ancestor.call(this)) + this._inherited("constructor", arguments); + }else{ + this._contextMethod(s, "constructor", arguments); + } + } + var ms = (self.constructor.mixins)||([]); + for(var i=0, m; (m=ms[i]); i++) { + (((m.prototype)&&(m.prototype.initializer))||(m)).apply(this, arguments); + } + if((!this.prototyping)&&(self.initializer)){ + self.initializer.apply(this, arguments); + } + } +} + +dojo.lang.declare._common = { + _getPropContext: function(){ return (this.___proto||this); }, + // caches ptype context and calls method on it + _contextMethod: function(ptype, method, args){ + var result, stack = this.___proto; + this.___proto = ptype; + try { result = ptype[method].apply(this,(args||[])); } + catch(e) { throw e; } + finally { this.___proto = stack; } + return result; + }, + _inherited: function(prop, args){ + // summary: + // Searches backward thru prototype chain to find nearest + // ancestral instance of prop. Internal use only. + var p = this._getPropContext(); + do{ + if((!p.constructor)||(!p.constructor.superclass)){ return; } + p = p.constructor.superclass; + }while(!(prop in p)); + return (dojo.lang.isFunction(p[prop]) ? this._contextMethod(p, prop, args) : p[prop]); + }, + inherited: function(prop, args){ + dojo.deprecated("'inherited' method is dangerous, do not up-call! 'inherited' is slated for removal in 0.5; name your super class (or use superclass property) instead.", "0.5"); + this._inherited(prop, args); + } +} + +dojo.declare = dojo.lang.declare; Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/declare.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/declare.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/declare.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/extras.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/extras.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/extras.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/extras.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,143 @@ +/* + 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.lang.extras"); + +dojo.require("dojo.lang.common"); + +dojo.lang.setTimeout = function(/*Function*/func, /*int*/delay /*, ...*/){ + // summary: + // Sets a timeout in milliseconds to execute a function in a given + // context with optional arguments. + // usage: + // dojo.lang.setTimeout(Object context, function func, number delay[, arg1[, ...]]); + // dojo.lang.setTimeout(function func, number delay[, arg1[, ...]]); + + var context = window, argsStart = 2; + if(!dojo.lang.isFunction(func)){ + context = func; + func = delay; + delay = arguments[2]; + argsStart++; + } + + if(dojo.lang.isString(func)){ + func = context[func]; + } + + var args = []; + for (var i = argsStart; i < arguments.length; i++){ + args.push(arguments[i]); + } + return dojo.global().setTimeout(function(){ func.apply(context, args); }, delay); // int +} + +dojo.lang.clearTimeout = function(/*int*/timer){ + // summary: clears timer by number from the execution queue + + // FIXME: + // why do we have this function? It's not portable outside of browser + // environments and it's a stupid wrapper on something that browsers + // provide anyway. + dojo.global().clearTimeout(timer); +} + +dojo.lang.getNameInObj = function(/*Object*/ns, /*unknown*/item){ + // summary: + // looks for a value in the object ns with a value matching item and + // returns the property name + // ns: if null, dj_global is used + // item: value to return a name for + if(!ns){ ns = dj_global; } + + for(var x in ns){ + if(ns[x] === item){ + return new String(x); // String + } + } + return null; // null +} + +dojo.lang.shallowCopy = function(/*Object*/obj, /*Boolean?*/deep){ + // summary: + // copies object obj one level deep, or full depth if deep is true + var i, ret; + + if(obj === null){ /*obj: null*/ return null; } // null + + if(dojo.lang.isObject(obj)){ + // obj: Object + ret = new obj.constructor(); + for(i in obj){ + if(dojo.lang.isUndefined(ret[i])){ + ret[i] = deep ? dojo.lang.shallowCopy(obj[i], deep) : obj[i]; + } + } + }else if(dojo.lang.isArray(obj)){ + // obj: Array + ret = []; + for(i=0; i<obj.length; i++){ + ret[i] = deep ? dojo.lang.shallowCopy(obj[i], deep) : obj[i]; + } + }else{ + // obj: Object + ret = obj; + } + + return ret; // Object +} + +dojo.lang.firstValued = function(/* ... */){ + // summary: Return the first argument that isn't undefined + + for(var i = 0; i < arguments.length; i++){ + if(typeof arguments[i] != "undefined"){ + return arguments[i]; // Object + } + } + return undefined; // undefined +} + +dojo.lang.getObjPathValue = function(/*String*/objpath, /*Object?*/context, /*Boolean?*/create){ + // summary: + // Gets a value from a reference specified as a string descriptor, + // (e.g. "A.B") in the given context. + // context: if not specified, dj_global is used + // create: if true, undefined objects in the path are created. + with(dojo.parseObjPath(objpath, context, create)){ + return dojo.evalProp(prop, obj, create); // Object + } +} + +dojo.lang.setObjPathValue = function(/*String*/objpath, /*anything*/value, /*Object?*/context, /*Boolean?*/create){ + // summary: + // Sets a value on a reference specified as a string descriptor. + // (e.g. "A.B") in the given context. This is similar to straight + // assignment, except that the object structure in question can + // optionally be created if it does not exist. + // context: if not specified, dj_global is used + // create: if true, undefined objects in the path are created. + + // FIXME: why is this function valuable? It should be scheduled for + // removal on the grounds that dojo.parseObjPath does most of it's work and + // is more straightforward and has fewer dependencies. Also, the order of + // arguments is bone-headed. "context" should clearly come after "create". + // *sigh* + dojo.deprecated("dojo.lang.setObjPathValue", "use dojo.parseObjPath and the '=' operator", "0.6"); + + if(arguments.length < 4){ + create = true; + } + with(dojo.parseObjPath(objpath, context, create)){ + if(obj && (create || (prop in obj))){ + obj[prop] = value; + } + } +} Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/extras.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/extras.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/extras.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/func.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/func.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/func.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/func.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,231 @@ +/* + 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.lang.func"); +dojo.require("dojo.lang.common"); + +dojo.lang.hitch = function(/*Object*/thisObject, /*Function|String*/method){ + // summary: + // Returns a function that will only ever execute in the a given scope + // (thisObject). This allows for easy use of object member functions + // in callbacks and other places in which the "this" keyword may + // otherwise not reference the expected scope. Note that the order of + // arguments may be reversed in a future version. + // thisObject: the scope to run the method in + // method: + // a function to be "bound" to thisObject or the name of the method in + // thisObject to be used as the basis for the binding + // usage: + // dojo.lang.hitch(foo, "bar")(); // runs foo.bar() in the scope of foo + // dojo.lang.hitch(foo, myFunction); // returns a function that runs myFunction in the scope of foo + + // FIXME: + // should this be extended to "fixate" arguments in a manner similar + // to dojo.lang.curry, but without the default execution of curry()? + var fcn = (dojo.lang.isString(method) ? thisObject[method] : method) || function(){}; + return function(){ + return fcn.apply(thisObject, arguments); // Function + }; +} + +dojo.lang.anonCtr = 0; +dojo.lang.anon = {}; + +dojo.lang.nameAnonFunc = function(/*Function*/anonFuncPtr, /*Object*/thisObj, /*Boolean*/searchForNames){ + // summary: + // Creates a reference to anonFuncPtr in thisObj with a completely + // unique name. The new name is returned as a String. If + // searchForNames is true, an effort will be made to locate an + // existing reference to anonFuncPtr in thisObj, and if one is found, + // the existing name will be returned instead. The default is for + // searchForNames to be false. + var nso = (thisObj|| dojo.lang.anon); + if( (searchForNames) || + ((dj_global["djConfig"])&&(djConfig["slowAnonFuncLookups"] == true)) ){ + for(var x in nso){ + try{ + if(nso[x] === anonFuncPtr){ + return x; + } + }catch(e){} // window.external fails in IE embedded in Eclipse (Eclipse bug #151165) + } + } + var ret = "__"+dojo.lang.anonCtr++; + while(typeof nso[ret] != "undefined"){ + ret = "__"+dojo.lang.anonCtr++; + } + nso[ret] = anonFuncPtr; + return ret; // String +} + +dojo.lang.forward = function(funcName){ + // summary: + // Returns a function that forwards a method call to + // this.funcName(...). Unlike dojo.lang.hitch(), the "this" scope is + // not fixed on a single object. Ported from MochiKit. + return function(){ + return this[funcName].apply(this, arguments); + }; // Function +} + +dojo.lang.curry = function(thisObj, func /* args ... */){ + // summary: + // similar to the curry() method found in many functional programming + // environments, this function returns an "argument accumulator" + // function, bound to a particular scope, and "primed" with a variable + // number of arguments. The curry method is unique in that it returns + // a function that may return other "partial" function which can be + // called repeatedly. New functions are returned until the arity of + // the original function is reached, at which point the underlying + // function (func) is called in the scope thisObj with all of the + // accumulated arguments (plus any extras) in positional order. + // examples: + // assuming a function defined like this: + // var foo = { + // bar: function(arg1, arg2, arg3){ + // dojo.debug.apply(dojo, arguments); + // } + // }; + // + // dojo.lang.curry() can be used most simply in this way: + // + // tmp = dojo.lang.curry(foo, foo.bar, "arg one", "thinger"); + // tmp("blah", "this is superfluous"); + // // debugs: "arg one thinger blah this is superfluous" + // tmp("blah"); + // // debugs: "arg one thinger blah" + // tmp(); + // // returns a function exactly like tmp that expects one argument + // + // other intermittent functions could be created until the 3 + // positional arguments are filled: + // + // tmp = dojo.lang.curry(foo, foo.bar, "arg one"); + // tmp2 = tmp("arg two"); + // tmp2("blah blah"); + // // debugs: "arg one arg two blah blah" + // tmp2("oy"); + // // debugs: "arg one arg two oy" + // + // curry() can also be used to call the function if enough arguments + // are passed in the initial invocation: + // + // dojo.lang.curry(foo, foo.bar, "one", "two", "three", "four"); + // // debugs: "one two three four" + // dojo.lang.curry(foo, foo.bar, "one", "two", "three"); + // // debugs: "one two three" + + + // FIXME: the order of func and thisObj should be changed!!! + var outerArgs = []; + thisObj = thisObj||dj_global; + if(dojo.lang.isString(func)){ + func = thisObj[func]; + } + for(var x=2; x<arguments.length; x++){ + outerArgs.push(arguments[x]); + } + // since the event system replaces the original function with a new + // join-point runner with an arity of 0, we check to see if it's left us + // any clues about the original arity in lieu of the function's actual + // length property + var ecount = (func["__preJoinArity"]||func.length) - outerArgs.length; + // borrowed from svend tofte + function gather(nextArgs, innerArgs, expected){ + var texpected = expected; + var totalArgs = innerArgs.slice(0); // copy + for(var x=0; x<nextArgs.length; x++){ + totalArgs.push(nextArgs[x]); + } + // check the list of provided nextArgs to see if it, plus the + // number of innerArgs already supplied, meets the total + // expected. + expected = expected-nextArgs.length; + if(expected<=0){ + var res = func.apply(thisObj, totalArgs); + expected = texpected; + return res; + }else{ + return function(){ + return gather(arguments,// check to see if we've been run + // with enough args + totalArgs, // a copy + expected); // how many more do we need to run?; + }; + } + } + return gather([], outerArgs, ecount); +} + +dojo.lang.curryArguments = function(/*Object*/thisObj, /*Function*/func, /*Array*/args, /*Integer, optional*/offset){ + // summary: + // similar to dojo.lang.curry(), except that a list of arguments to + // start the curry with may be provided as an array instead of as + // positional arguments. An offset may be specified from the 0 index + // to skip some elements in args. + var targs = []; + var x = offset||0; + for(x=offset; x<args.length; x++){ + targs.push(args[x]); // ensure that it's an arr + } + return dojo.lang.curry.apply(dojo.lang, [thisObj, func].concat(targs)); +} + +dojo.lang.tryThese = function(/*...*/){ + // summary: + // executes each function argument in turn, returning the return value + // from the first one which does not throw an exception in execution. + // Any number of functions may be passed. + for(var x=0; x<arguments.length; x++){ + try{ + if(typeof arguments[x] == "function"){ + var ret = (arguments[x]()); + if(ret){ + return ret; + } + } + }catch(e){ + dojo.debug(e); + } + } +} + +dojo.lang.delayThese = function(/*Array*/farr, /*Function, optional*/cb, /*Integer*/delay, /*Function, optional*/onend){ + // summary: + // executes a series of functions contained in farr, but spaces out + // calls to each function by the millisecond delay provided. If cb is + // provided, it will be called directly after each item in farr is + // called and if onend is passed, it will be called when all items + // have completed executing. + + /** + * alternate: (array funcArray, function callback, function onend) + * alternate: (array funcArray, function callback) + * alternate: (array funcArray) + */ + if(!farr.length){ + if(typeof onend == "function"){ + onend(); + } + return; + } + if((typeof delay == "undefined")&&(typeof cb == "number")){ + delay = cb; + cb = function(){}; + }else if(!cb){ + cb = function(){}; + if(!delay){ delay = 0; } + } + setTimeout(function(){ + (farr.shift())(); + cb(); + dojo.lang.delayThese(farr, cb, delay, onend); + }, delay); +} Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/func.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/func.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/func.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/repr.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/repr.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/repr.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/repr.js Mon Feb 19 09:56:06 2007 @@ -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.lang.repr"); + +dojo.require("dojo.lang.common"); +dojo.require("dojo.AdapterRegistry"); +dojo.require("dojo.string.extras"); + +dojo.lang.reprRegistry = new dojo.AdapterRegistry(); +dojo.lang.registerRepr = function(/*String*/name, /*Function*/check, /*Function*/wrap, /*Boolean?*/override){ + // summary: + // Register a repr function. repr functions should take + // one argument and return a string representation of it + // suitable for developers, primarily used when debugging. + // + // If override is given, it is used as the highest priority + // repr, otherwise it will be used as the lowest. + + dojo.lang.reprRegistry.register(name, check, wrap, override); +}; + +dojo.lang.repr = function(/*Object*/obj){ + // summary: Return a "programmer representation" for an object + // description: returns a string representation of an object suitable for developers, primarily used when debugging + + if(typeof(obj) == "undefined"){ + // obj: undefined + return "undefined"; // String + }else if(obj === null){ + // obj: null + return "null"; // String + } + + try{ + if(typeof(obj["__repr__"]) == 'function'){ + return obj["__repr__"](); + }else if((typeof(obj["repr"]) == 'function')&&(obj.repr != arguments.callee)){ + return obj["repr"](); + } + return dojo.lang.reprRegistry.match(obj); + }catch(e){ + if(typeof(obj.NAME) == 'string' && ( + obj.toString == Function.prototype.toString || + obj.toString == Object.prototype.toString + )){ + return obj.NAME; // String + } + } + + if(typeof(obj) == "function"){ + // obj: Function + obj = (obj + "").replace(/^\s+/, ""); + var idx = obj.indexOf("{"); + if(idx != -1){ + obj = obj.substr(0, idx) + "{...}"; + } + } + return obj + ""; // String +} + +dojo.lang.reprArrayLike = function(/*Array*/arr){ + // summary: Maps each element of arr to dojo.lang.repr and provides output in an array-like format + // description: returns an array-like string representation of the provided array suitable for developers, primarily used when debugging + try{ + var na = dojo.lang.map(arr, dojo.lang.repr); + return "[" + na.join(", ") + "]"; // String + }catch(e){ } +}; + +(function(){ + var m = dojo.lang; + m.registerRepr("arrayLike", m.isArrayLike, m.reprArrayLike); + m.registerRepr("string", m.isString, m.reprString); + m.registerRepr("numbers", m.isNumber, m.reprNumber); + m.registerRepr("boolean", m.isBoolean, m.reprNumber); + // m.registerRepr("numbers", m.typeMatcher("number", "boolean"), m.reprNumber); +})(); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/repr.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/repr.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/repr.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Streamer.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Streamer.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Streamer.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Streamer.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,99 @@ +/* + 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.lang.timing.Streamer"); +dojo.require("dojo.lang.timing.Timer"); + +dojo.lang.timing.Streamer = function( + /* function */input, + /* function */output, + /* int */interval, + /* int */minimum, + /* array */initialData +){ + // summary + // Streamer will take an input function that pushes N datapoints into a + // queue, and will pass the next point in that queue out to an + // output function at the passed interval; this way you can emulate + // a constant buffered stream of data. + // input: the function executed when the internal queue reaches minimumSize + // output: the function executed on internal tick + // interval: the interval in ms at which the output function is fired. + // minimum: the minimum number of elements in the internal queue. + + var self = this; + var queue = []; + + // public properties + this.interval = interval || 1000; + this.minimumSize = minimum || 10; // latency usually == interval * minimumSize + this.inputFunction = input || function(q){ }; + this.outputFunction = output || function(point){ }; + + // more setup + var timer = new dojo.lang.timing.Timer(this.interval); + var tick = function(){ + self.onTick(self); + + if(queue.length < self.minimumSize){ + self.inputFunction(queue); + } + + var obj = queue.shift(); + while(typeof(obj) == "undefined" && queue.length > 0){ + obj = queue.shift(); + } + + // check to see if the input function needs to be fired + // stop before firing the output function + // TODO: relegate this to the output function? + if(typeof(obj) == "undefined"){ + self.stop(); + return; + } + + // call the output function. + self.outputFunction(obj); + }; + + this.setInterval = function(/* int */ms){ + // summary + // sets the interval in milliseconds of the internal timer + this.interval = ms; + timer.setInterval(ms); + }; + + this.onTick = function(/* dojo.lang.timing.Streamer */obj){ }; + // wrap the timer functions so that we can connect to them if needed. + this.start = function(){ + // summary + // starts the Streamer + if(typeof(this.inputFunction) == "function" && typeof(this.outputFunction) == "function"){ + timer.start(); + return; + } + dojo.raise("You cannot start a Streamer without an input and an output function."); + }; + this.onStart = function(){ }; + this.stop = function(){ + // summary + // stops the Streamer + timer.stop(); + }; + this.onStop = function(){ }; + + // finish initialization + timer.onTick = this.tick; + timer.onStart = this.onStart; + timer.onStop = this.onStop; + if(initialData){ + queue.concat(initialData); + } +}; Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Streamer.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Streamer.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Streamer.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Timer.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Timer.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Timer.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Timer.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,64 @@ +/* + 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.lang.timing.Timer"); +dojo.require("dojo.lang.func"); + +dojo.lang.timing.Timer = function(/*int*/ interval){ + // summary: Timer object executes an "onTick()" method repeatedly at a specified interval. + // repeatedly at a given interval. + // interval: Interval between function calls, in milliseconds. + this.timer = null; + this.isRunning = false; + this.interval = interval; + + this.onStart = null; + this.onStop = null; +}; + +dojo.extend(dojo.lang.timing.Timer, { + onTick : function(){ + // summary: Method called every time the interval passes. Override to do something useful. + }, + + setInterval : function(interval){ + // summary: Reset the interval of a timer, whether running or not. + // interval: New interval, in milliseconds. + if (this.isRunning){ + dj_global.clearInterval(this.timer); + } + this.interval = interval; + if (this.isRunning){ + this.timer = dj_global.setInterval(dojo.lang.hitch(this, "onTick"), this.interval); + } + }, + + start : function(){ + // summary: Start the timer ticking. + // description: Calls the "onStart()" handler, if defined. + // Note that the onTick() function is not called right away, + // only after first interval passes. + if (typeof this.onStart == "function"){ + this.onStart(); + } + this.isRunning = true; + this.timer = dj_global.setInterval(dojo.lang.hitch(this, "onTick"), this.interval); + }, + + stop : function(){ + // summary: Stop the timer. + // description: Calls the "onStop()" handler, if defined. + if (typeof this.onStop == "function"){ + this.onStop(); + } + this.isRunning = false; + dj_global.clearInterval(this.timer); + } +}); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Timer.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Timer.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/Timer.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/__package__.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/__package__.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/__package__.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/__package__.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,11 @@ +/* + 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.lang.timing.*"); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/__package__.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/__package__.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/timing/__package__.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/type.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/type.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/type.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/lang/type.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,245 @@ +/* + 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.lang.type"); +dojo.require("dojo.lang.common"); + +dojo.lang.whatAmI = function(value) { + dojo.deprecated("dojo.lang.whatAmI", "use dojo.lang.getType instead", "0.5"); + return dojo.lang.getType(value); +} +dojo.lang.whatAmI.custom = {}; + +dojo.lang.getType = function(/* anything */ value){ + // summary: Attempts to determine what type value is. + // value: Any literal value or object instance. + try{ + if(dojo.lang.isArray(value)){ + return "array"; // string + } + if(dojo.lang.isFunction(value)){ + re |
«
Return to OFBiz - Commits
|
1 view|%1 views
| Free forum by Nabble | Edit this page |