| /tags/v5.0-ouadji/api/js/dojo/src/lang/assert.js |
|---|
| New file |
| 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.lang.assert"); |
| dojo.require("dojo.lang.common"); |
| dojo.require("dojo.lang.array"); |
| dojo.require("dojo.lang.type"); |
| dojo.lang.assert = function (booleanValue, message) { |
| 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"; |
| } |
| throw new Error(errorMessage); |
| } |
| }; |
| dojo.lang.assertType = function (value, type, keywordParameters) { |
| 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, expectedProperties, message) { |
| 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); |
| } |
| } |
| } |
| }; |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/type.js |
|---|
| New file |
| 0,0 → 1,145 |
| /* |
| 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 (value) { |
| try { |
| if (dojo.lang.isArray(value)) { |
| return "array"; |
| } |
| if (dojo.lang.isFunction(value)) { |
| return "function"; |
| } |
| if (dojo.lang.isString(value)) { |
| return "string"; |
| } |
| if (dojo.lang.isNumber(value)) { |
| return "number"; |
| } |
| if (dojo.lang.isBoolean(value)) { |
| return "boolean"; |
| } |
| if (dojo.lang.isAlien(value)) { |
| return "alien"; |
| } |
| if (dojo.lang.isUndefined(value)) { |
| return "undefined"; |
| } |
| for (var name in dojo.lang.whatAmI.custom) { |
| if (dojo.lang.whatAmI.custom[name](value)) { |
| return name; |
| } |
| } |
| if (dojo.lang.isObject(value)) { |
| return "object"; |
| } |
| } |
| catch (e) { |
| } |
| return "unknown"; |
| }; |
| dojo.lang.isNumeric = function (value) { |
| return (!isNaN(value) && isFinite(value) && (value != null) && !dojo.lang.isBoolean(value) && !dojo.lang.isArray(value) && !/^\s*$/.test(value)); |
| }; |
| dojo.lang.isBuiltIn = function (value) { |
| return (dojo.lang.isArray(value) || dojo.lang.isFunction(value) || dojo.lang.isString(value) || dojo.lang.isNumber(value) || dojo.lang.isBoolean(value) || (value == null) || (value instanceof Error) || (typeof value == "error")); |
| }; |
| dojo.lang.isPureObject = function (value) { |
| return ((value != null) && dojo.lang.isObject(value) && value.constructor == Object); |
| }; |
| dojo.lang.isOfType = function (value, type, keywordParameters) { |
| var optional = false; |
| if (keywordParameters) { |
| optional = keywordParameters["optional"]; |
| } |
| if (optional && ((value === null) || dojo.lang.isUndefined(value))) { |
| return true; |
| } |
| if (dojo.lang.isArray(type)) { |
| var arrayOfTypes = type; |
| for (var i in arrayOfTypes) { |
| var aType = arrayOfTypes[i]; |
| if (dojo.lang.isOfType(value, aType)) { |
| return true; |
| } |
| } |
| return false; |
| } else { |
| if (dojo.lang.isString(type)) { |
| type = type.toLowerCase(); |
| } |
| switch (type) { |
| case Array: |
| case "array": |
| return dojo.lang.isArray(value); |
| case Function: |
| case "function": |
| return dojo.lang.isFunction(value); |
| case String: |
| case "string": |
| return dojo.lang.isString(value); |
| case Number: |
| case "number": |
| return dojo.lang.isNumber(value); |
| case "numeric": |
| return dojo.lang.isNumeric(value); |
| case Boolean: |
| case "boolean": |
| return dojo.lang.isBoolean(value); |
| case Object: |
| case "object": |
| return dojo.lang.isObject(value); |
| case "pureobject": |
| return dojo.lang.isPureObject(value); |
| case "builtin": |
| return dojo.lang.isBuiltIn(value); |
| case "alien": |
| return dojo.lang.isAlien(value); |
| case "undefined": |
| return dojo.lang.isUndefined(value); |
| case null: |
| case "null": |
| return (value === null); |
| case "optional": |
| dojo.deprecated("dojo.lang.isOfType(value, [type, \"optional\"])", "use dojo.lang.isOfType(value, type, {optional: true} ) instead", "0.5"); |
| return ((value === null) || dojo.lang.isUndefined(value)); |
| default: |
| if (dojo.lang.isFunction(type)) { |
| return (value instanceof type); |
| } else { |
| dojo.raise("dojo.lang.isOfType() was passed an invalid type"); |
| } |
| } |
| } |
| dojo.raise("If we get here, it means a bug was introduced above."); |
| }; |
| dojo.lang.getObject = function (str) { |
| var parts = str.split("."), i = 0, obj = dj_global; |
| do { |
| obj = obj[parts[i++]]; |
| } while (i < parts.length && obj); |
| return (obj != dj_global) ? obj : null; |
| }; |
| dojo.lang.doesObjectExist = function (str) { |
| var parts = str.split("."), i = 0, obj = dj_global; |
| do { |
| obj = obj[parts[i++]]; |
| } while (i < parts.length && obj); |
| return (obj && obj != dj_global); |
| }; |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/extras.js |
|---|
| New file |
| 0,0 → 1,96 |
| /* |
| 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 (func, delay) { |
| 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); |
| }; |
| dojo.lang.clearTimeout = function (timer) { |
| dojo.global().clearTimeout(timer); |
| }; |
| dojo.lang.getNameInObj = function (ns, item) { |
| if (!ns) { |
| ns = dj_global; |
| } |
| for (var x in ns) { |
| if (ns[x] === item) { |
| return new String(x); |
| } |
| } |
| return null; |
| }; |
| dojo.lang.shallowCopy = function (obj, deep) { |
| var i, ret; |
| if (obj === null) { |
| return null; |
| } |
| if (dojo.lang.isObject(obj)) { |
| 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)) { |
| ret = []; |
| for (i = 0; i < obj.length; i++) { |
| ret[i] = deep ? dojo.lang.shallowCopy(obj[i], deep) : obj[i]; |
| } |
| } else { |
| ret = obj; |
| } |
| } |
| return ret; |
| }; |
| dojo.lang.firstValued = function () { |
| for (var i = 0; i < arguments.length; i++) { |
| if (typeof arguments[i] != "undefined") { |
| return arguments[i]; |
| } |
| } |
| return undefined; |
| }; |
| dojo.lang.getObjPathValue = function (objpath, context, create) { |
| with (dojo.parseObjPath(objpath, context, create)) { |
| return dojo.evalProp(prop, obj, create); |
| } |
| }; |
| dojo.lang.setObjPathValue = function (objpath, value, context, create) { |
| 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; |
| } |
| } |
| }; |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/__package__.js |
|---|
| New file |
| 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.kwCompoundRequire({common:["dojo.lang.common", "dojo.lang.assert", "dojo.lang.array", "dojo.lang.type", "dojo.lang.func", "dojo.lang.extras", "dojo.lang.repr", "dojo.lang.declare"]}); |
| dojo.provide("dojo.lang.*"); |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/common.js |
|---|
| New file |
| 0,0 → 1,156 |
| /* |
| 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 (subclass, superclass) { |
| 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; |
| subclass["super"] = superclass.prototype; |
| }; |
| dojo.lang._mixin = function (obj, props) { |
| var tobj = {}; |
| for (var x in props) { |
| if ((typeof tobj[x] == "undefined") || (tobj[x] != props[x])) { |
| obj[x] = props[x]; |
| } |
| } |
| if (dojo.render.html.ie && (typeof (props["toString"]) == "function") && (props["toString"] != obj["toString"]) && (props["toString"] != tobj["toString"])) { |
| obj.toString = props.toString; |
| } |
| return obj; |
| }; |
| dojo.lang.mixin = function (obj, props) { |
| for (var i = 1, l = arguments.length; i < l; i++) { |
| dojo.lang._mixin(obj, arguments[i]); |
| } |
| return obj; |
| }; |
| dojo.lang.extend = function (constructor, props) { |
| for (var i = 1, l = arguments.length; i < l; i++) { |
| dojo.lang._mixin(constructor.prototype, arguments[i]); |
| } |
| return constructor; |
| }; |
| dojo.inherits = dojo.lang.inherits; |
| dojo.mixin = dojo.lang.mixin; |
| dojo.extend = dojo.lang.extend; |
| dojo.lang.find = function (array, value, identity, findLast) { |
| 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; |
| }; |
| dojo.lang.indexOf = dojo.lang.find; |
| dojo.lang.findLast = function (array, value, identity) { |
| return dojo.lang.find(array, value, identity, true); |
| }; |
| dojo.lang.lastIndexOf = dojo.lang.findLast; |
| dojo.lang.inArray = function (array, value) { |
| return dojo.lang.find(array, value) > -1; |
| }; |
| dojo.lang.isObject = function (it) { |
| if (typeof it == "undefined") { |
| return false; |
| } |
| return (typeof it == "object" || it === null || dojo.lang.isArray(it) || dojo.lang.isFunction(it)); |
| }; |
| dojo.lang.isArray = function (it) { |
| return (it && it instanceof Array || typeof it == "array"); |
| }; |
| dojo.lang.isArrayLike = function (it) { |
| if ((!it) || (dojo.lang.isUndefined(it))) { |
| return false; |
| } |
| if (dojo.lang.isString(it)) { |
| return false; |
| } |
| if (dojo.lang.isFunction(it)) { |
| return false; |
| } |
| if (dojo.lang.isArray(it)) { |
| return true; |
| } |
| if ((it.tagName) && (it.tagName.toLowerCase() == "form")) { |
| return false; |
| } |
| if (dojo.lang.isNumber(it.length) && isFinite(it.length)) { |
| return true; |
| } |
| return false; |
| }; |
| dojo.lang.isFunction = function (it) { |
| return (it instanceof Function || typeof it == "function"); |
| }; |
| (function () { |
| if ((dojo.render.html.capable) && (dojo.render.html["safari"])) { |
| dojo.lang.isFunction = function (it) { |
| if ((typeof (it) == "function") && (it == "[object NodeList]")) { |
| return false; |
| } |
| return (it instanceof Function || typeof it == "function"); |
| }; |
| } |
| })(); |
| dojo.lang.isString = function (it) { |
| return (typeof it == "string" || it instanceof String); |
| }; |
| dojo.lang.isAlien = function (it) { |
| if (!it) { |
| return false; |
| } |
| return !dojo.lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); |
| }; |
| dojo.lang.isBoolean = function (it) { |
| return (it instanceof Boolean || typeof it == "boolean"); |
| }; |
| dojo.lang.isNumber = function (it) { |
| return (it instanceof Number || typeof it == "number"); |
| }; |
| dojo.lang.isUndefined = function (it) { |
| return ((typeof (it) == "undefined") && (it == undefined)); |
| }; |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/repr.js |
|---|
| New file |
| 0,0 → 1,68 |
| /* |
| 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 (name, check, wrap, override) { |
| dojo.lang.reprRegistry.register(name, check, wrap, override); |
| }; |
| dojo.lang.repr = function (obj) { |
| if (typeof (obj) == "undefined") { |
| return "undefined"; |
| } else { |
| if (obj === null) { |
| return "null"; |
| } |
| } |
| 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; |
| } |
| } |
| if (typeof (obj) == "function") { |
| obj = (obj + "").replace(/^\s+/, ""); |
| var idx = obj.indexOf("{"); |
| if (idx != -1) { |
| obj = obj.substr(0, idx) + "{...}"; |
| } |
| } |
| return obj + ""; |
| }; |
| dojo.lang.reprArrayLike = function (arr) { |
| try { |
| var na = dojo.lang.map(arr, dojo.lang.repr); |
| return "[" + na.join(", ") + "]"; |
| } |
| 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); |
| })(); |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/func.js |
|---|
| New file |
| 0,0 → 1,135 |
| /* |
| 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 (thisObject, method) { |
| var args = []; |
| for (var x = 2; x < arguments.length; x++) { |
| args.push(arguments[x]); |
| } |
| var fcn = (dojo.lang.isString(method) ? thisObject[method] : method) || function () { |
| }; |
| return function () { |
| var ta = args.concat([]); |
| for (var x = 0; x < arguments.length; x++) { |
| ta.push(arguments[x]); |
| } |
| return fcn.apply(thisObject, ta); |
| }; |
| }; |
| dojo.lang.anonCtr = 0; |
| dojo.lang.anon = {}; |
| dojo.lang.nameAnonFunc = function (anonFuncPtr, thisObj, searchForNames) { |
| 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) { |
| } |
| } |
| } |
| var ret = "__" + dojo.lang.anonCtr++; |
| while (typeof nso[ret] != "undefined") { |
| ret = "__" + dojo.lang.anonCtr++; |
| } |
| nso[ret] = anonFuncPtr; |
| return ret; |
| }; |
| dojo.lang.forward = function (funcName) { |
| return function () { |
| return this[funcName].apply(this, arguments); |
| }; |
| }; |
| dojo.lang.curry = function (thisObj, func) { |
| 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]); |
| } |
| var ecount = (func["__preJoinArity"] || func.length) - outerArgs.length; |
| function gather(nextArgs, innerArgs, expected) { |
| var texpected = expected; |
| var totalArgs = innerArgs.slice(0); |
| for (var x = 0; x < nextArgs.length; x++) { |
| totalArgs.push(nextArgs[x]); |
| } |
| expected = expected - nextArgs.length; |
| if (expected <= 0) { |
| var res = func.apply(thisObj, totalArgs); |
| expected = texpected; |
| return res; |
| } else { |
| return function () { |
| return gather(arguments, totalArgs, expected); |
| }; |
| } |
| } |
| return gather([], outerArgs, ecount); |
| }; |
| dojo.lang.curryArguments = function (thisObj, func, args, offset) { |
| var targs = []; |
| var x = offset || 0; |
| for (x = offset; x < args.length; x++) { |
| targs.push(args[x]); |
| } |
| return dojo.lang.curry.apply(dojo.lang, [thisObj, func].concat(targs)); |
| }; |
| dojo.lang.tryThese = function () { |
| 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 (farr, cb, delay, onend) { |
| 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); |
| }; |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/timing/Timer.js |
|---|
| New file |
| 0,0 → 1,44 |
| /* |
| 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 (interval) { |
| this.timer = null; |
| this.isRunning = false; |
| this.interval = interval; |
| this.onStart = null; |
| this.onStop = null; |
| }; |
| dojo.extend(dojo.lang.timing.Timer, {onTick:function () { |
| }, setInterval:function (interval) { |
| 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 () { |
| if (typeof this.onStart == "function") { |
| this.onStart(); |
| } |
| this.isRunning = true; |
| this.timer = dj_global.setInterval(dojo.lang.hitch(this, "onTick"), this.interval); |
| }, stop:function () { |
| if (typeof this.onStop == "function") { |
| this.onStop(); |
| } |
| this.isRunning = false; |
| dj_global.clearInterval(this.timer); |
| }}); |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/timing/Streamer.js |
|---|
| New file |
| 0,0 → 1,67 |
| /* |
| 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 (input, output, interval, minimum, initialData) { |
| var self = this; |
| var queue = []; |
| this.interval = interval || 1000; |
| this.minimumSize = minimum || 10; |
| this.inputFunction = input || function (q) { |
| }; |
| this.outputFunction = output || function (point) { |
| }; |
| 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(); |
| } |
| if (typeof (obj) == "undefined") { |
| self.stop(); |
| return; |
| } |
| self.outputFunction(obj); |
| }; |
| this.setInterval = function (ms) { |
| this.interval = ms; |
| timer.setInterval(ms); |
| }; |
| this.onTick = function (obj) { |
| }; |
| this.start = function () { |
| 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 () { |
| timer.stop(); |
| }; |
| this.onStop = function () { |
| }; |
| timer.onTick = this.tick; |
| timer.onStart = this.onStart; |
| timer.onStop = this.onStop; |
| if (initialData) { |
| queue.concat(initialData); |
| } |
| }; |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/timing/__package__.js |
|---|
| New file |
| 0,0 → 1,14 |
| /* |
| Copyright (c) 2004-2006, The Dojo Foundation |
| All Rights Reserved. |
| Licensed under the Academic Free License version 2.1 or above OR the |
| modified BSD license. For more information on Dojo licensing, see: |
| http://dojotoolkit.org/community/licensing.shtml |
| */ |
| dojo.provide("dojo.lang.timing.*"); |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/array.js |
|---|
| New file |
| 0,0 → 1,176 |
| /* |
| Copyright (c) 2004-2006, The Dojo Foundation |
| All Rights Reserved. |
| Licensed under the Academic Free License version 2.1 or above OR the |
| modified BSD license. For more information on Dojo licensing, see: |
| http://dojotoolkit.org/community/licensing.shtml |
| */ |
| dojo.provide("dojo.lang.array"); |
| dojo.require("dojo.lang.common"); |
| dojo.lang.mixin(dojo.lang, {has:function (obj, name) { |
| try { |
| return typeof obj[name] != "undefined"; |
| } |
| catch (e) { |
| return false; |
| } |
| }, isEmpty:function (obj) { |
| 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; |
| } else { |
| if (dojo.lang.isArrayLike(obj) || dojo.lang.isString(obj)) { |
| return obj.length == 0; |
| } |
| } |
| }, map:function (arr, obj, unary_func) { |
| var isString = dojo.lang.isString(arr); |
| if (isString) { |
| arr = arr.split(""); |
| } |
| if (dojo.lang.isFunction(obj) && (!unary_func)) { |
| unary_func = obj; |
| obj = dj_global; |
| } else { |
| if (dojo.lang.isFunction(obj) && unary_func) { |
| 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(""); |
| } else { |
| return outArr; |
| } |
| }, reduce:function (arr, initialValue, obj, binary_func) { |
| var reducedValue = initialValue; |
| if (arguments.length == 2) { |
| binary_func = initialValue; |
| reducedValue = arr[0]; |
| arr = arr.slice(1); |
| } else { |
| if (arguments.length == 3) { |
| if (dojo.lang.isFunction(obj)) { |
| binary_func = obj; |
| obj = null; |
| } |
| } else { |
| if (dojo.lang.isFunction(obj)) { |
| var tmp = binary_func; |
| binary_func = obj; |
| obj = tmp; |
| } |
| } |
| } |
| var ob = obj || dj_global; |
| dojo.lang.map(arr, function (val) { |
| reducedValue = binary_func.call(ob, reducedValue, val); |
| }); |
| return reducedValue; |
| }, forEach:function (anArray, callback, thisObject) { |
| if (dojo.lang.isString(anArray)) { |
| anArray = anArray.split(""); |
| } |
| if (Array.forEach) { |
| Array.forEach(anArray, callback, thisObject); |
| } else { |
| if (!thisObject) { |
| thisObject = dj_global; |
| } |
| for (var i = 0, l = anArray.length; i < l; i++) { |
| callback.call(thisObject, anArray[i], i, anArray); |
| } |
| } |
| }, _everyOrSome:function (every, arr, callback, thisObject) { |
| if (dojo.lang.isString(arr)) { |
| 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; |
| } else { |
| if ((!every) && (result)) { |
| return true; |
| } |
| } |
| } |
| return Boolean(every); |
| } |
| }, every:function (arr, callback, thisObject) { |
| return this._everyOrSome(true, arr, callback, thisObject); |
| }, some:function (arr, callback, thisObject) { |
| return this._everyOrSome(false, arr, callback, thisObject); |
| }, filter:function (arr, callback, thisObject) { |
| var isString = dojo.lang.isString(arr); |
| if (isString) { |
| 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(""); |
| } else { |
| return outArr; |
| } |
| }, unnest:function () { |
| 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; |
| }, toArray:function (arrayLike, startOffset) { |
| var array = []; |
| for (var i = startOffset || 0; i < arrayLike.length; i++) { |
| array.push(arrayLike[i]); |
| } |
| return array; |
| }}); |
| /tags/v5.0-ouadji/api/js/dojo/src/lang/declare.js |
|---|
| New file |
| 0,0 → 1,109 |
| /* |
| 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 (className, superclass, init, props) { |
| if ((dojo.lang.isFunction(props)) || ((!props) && (!dojo.lang.isFunction(init)))) { |
| 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; |
| }; |
| dojo.lang.declare._makeConstructor = function () { |
| return function () { |
| var self = this._getPropContext(); |
| var s = self.constructor.superclass; |
| if ((s) && (s.constructor)) { |
| if (s.constructor == arguments.callee) { |
| 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); |
| }, _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) { |
| 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; |