svn commit: r509273 [26/50] - in /ofbiz/trunk/framework/images/
Locked
svn commit: r509273 [26/50] - in /ofbiz/trunk/framework/images/
 
|
Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/loader_xd.js
URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/loader_xd.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/loader_xd.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/loader_xd.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,548 @@ +/* + 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 +*/ + +//Cross-domain package loader. + +//FIXME: How will xd loading work with debugAtAllCosts? Any bad interactions? +//FIXME: widgets won't work fully (HTML/CSS) and also because of the requireIf() thing. + +dojo.hostenv.resetXd = function(){ + //summary: Internal xd loader function. Resets the xd state. + + //This flag indicates where or not we have crossed into xdomain territory. Once any package says + //it is cross domain, then the rest of the packages have to be treated as xdomain because we need + //to evaluate packages in order. If there is a xdomain package followed by a xhr package, we can't load + //the xhr package until the one before it finishes loading. The text of the xhr package will be converted + //to match the format for a xd package and put in the xd load queue. + //You can force all packages to be treated as xd by setting the djConfig.forceXDomain. + this.isXDomain = djConfig.forceXDomain || false; + + this.xdTimer = 0; + this.xdInFlight = {}; + this.xdOrderedReqs = []; + this.xdDepMap = {}; + this.xdContents = []; +} + +//Call reset immediately to set the state. +dojo.hostenv.resetXd(); + +dojo.hostenv.createXdPackage = function(/*String*/contents){ + //summary: Internal xd loader function. Creates an xd module source given an + //non-xd module contents. + + //Find dependencies. + var deps = []; + var depRegExp = /dojo.(require|requireIf|requireAll|provide|requireAfterIf|requireAfter|kwCompoundRequire|conditionalRequire|hostenv\.conditionalLoadModule|.hostenv\.loadModule|hostenv\.moduleLoaded)\(([\w\W]*?)\)/mg; + var match; + while((match = depRegExp.exec(contents)) != null){ + deps.push("\"" + match[1] + "\", " + match[2]); + } + + //Create package object and the call to packageLoaded. + var output = []; + output.push("dojo.hostenv.packageLoaded({\n"); + + //Add dependencies + if(deps.length > 0){ + output.push("depends: ["); + for(var i = 0; i < deps.length; i++){ + if(i > 0){ + output.push(",\n"); + } + output.push("[" + deps[i] + "]"); + } + output.push("],"); + } + + //Add the contents of the file inside a function. + //Pass in dojo as an argument to the function to help with + //allowing multiple versions of dojo in a page. + output.push("\ndefinePackage: function(dojo){"); + output.push(contents); + output.push("\n}});"); + + return output.join(""); //String +} + +dojo.hostenv.loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){ + //summary: Internal xd loader function. Overrides loadPath() from loader.js. + //xd loading requires slightly different behavior from loadPath(). + + + //Only do getBaseScriptUri if path does not start with a URL with a protocol. + //If there is a colon before the first / then, we have a URL with a protocol. + var colonIndex = relpath.indexOf(":"); + var slashIndex = relpath.indexOf("/"); + var uri; + var currentIsXDomain = false; + if(colonIndex > 0 && colonIndex < slashIndex){ + uri = relpath; + this.isXDomain = currentIsXDomain = true; + }else{ + uri = this.getBaseScriptUri() + relpath; + + //Is ithe base script URI-based URL a cross domain URL? + colonIndex = uri.indexOf(":"); + slashIndex = uri.indexOf("/"); + if(colonIndex > 0 && colonIndex < slashIndex && (!location.host || uri.indexOf("http://" + location.host) != 0)){ + this.isXDomain = currentIsXDomain = true; + } + } + + if(djConfig.cacheBust && dojo.render.html.capable) { uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,""); } + try{ + return ((!module || this.isXDomain) ? this.loadUri(uri, cb, currentIsXDomain, module) : this.loadUriAndCheck(uri, module, cb)); //boolean + }catch(e){ + dojo.debug(e); + return false; //boolean + } +} + +dojo.hostenv.loadUri = function(/*String*/uri, /*Function?*/cb, /*boolean*/currentIsXDomain, /*String?*/module){ + //summary: Internal xd loader function. Overrides loadUri() from loader.js. + // xd loading requires slightly different behavior from loadPath(). + //description: Wanted to override getText(), but it is used by + // the widget code in too many, synchronous ways right now. + if(this.loadedUris[uri]){ + return 1; //boolean + } + + //Add the module (package) to the list of modules. + if(this.isXDomain){ + //Curious: is this array going to get whacked with multiple access since scripts + //load asynchronously and may be accessing the array at the same time? + //JS is single-threaded supposedly, so it should be ok. And we don't need + //a precise ordering. + this.xdOrderedReqs.push(module); + + //Add to waiting packages. + //If this is a __package__.js file, then this must be + //a package.* request (since xdomain can only work with the first + //path in a package search list. However, .* module names are not + //passed to this function, so do an adjustment here. + if(uri.indexOf("__package__") != -1){ + module += ".*"; + } + + this.xdInFlight[module] = true; + + //Increment inFlightCount + //This will stop the modulesLoaded from firing all the way. + this.inFlightCount++; + + //Start timer + if(!this.xdTimer){ + this.xdTimer = setInterval("dojo.hostenv.watchInFlightXDomain();", 100); + } + this.xdStartTime = (new Date()).getTime(); + } + + if (currentIsXDomain){ + //Fix name to be a .xd.fileextension name. + var lastIndex = uri.lastIndexOf('.'); + if(lastIndex <= 0){ + lastIndex = uri.length - 1; + } + + var xdUri = uri.substring(0, lastIndex) + ".xd"; + if(lastIndex != uri.length - 1){ + xdUri += uri.substring(lastIndex, uri.length); + } + + //Add to script src + var element = document.createElement("script"); + element.type = "text/javascript"; + element.src = xdUri; + if(!this.headElement){ + this.headElement = document.getElementsByTagName("head")[0]; + } + this.headElement.appendChild(element); + }else{ + var contents = this.getText(uri, null, true); + if(contents == null){ return 0; /*boolean*/} + + if(this.isXDomain){ + var pkg = this.createXdPackage(contents); + dj_eval(pkg); + }else{ + if(cb){ contents = '('+contents+')'; } + var value = dj_eval(contents); + if(cb){ + cb(value); + } + } + } + + //These steps are done in the non-xd loader version of this function. + //Maintain these steps to fit in with the existing system. + this.loadedUris[uri] = true; + return 1; //boolean +} + +dojo.hostenv.packageLoaded = function(/*Object*/pkg){ + //summary: Internal xd loader function. Called by an xd module when + //it has been loaded via a script tag. + var deps = pkg.depends; + var requireList = null; + var requireAfterList = null; + var provideList = []; + if(deps && deps.length > 0){ + var dep = null; + var insertHint = 0; + var attachedPackage = false; + for(var i = 0; i < deps.length; i++){ + dep = deps[i]; + + //Look for specific dependency indicators. + if (dep[0] == "provide" || dep[0] == "hostenv.moduleLoaded"){ + provideList.push(dep[1]); + }else{ + if(!requireList){ + requireList = []; + } + if(!requireAfterList){ + requireAfterList = []; + } + + var unpackedDeps = this.unpackXdDependency(dep); + if(unpackedDeps.requires){ + requireList = requireList.concat(unpackedDeps.requires); + } + if(unpackedDeps.requiresAfter){ + requireAfterList = requireAfterList.concat(unpackedDeps.requiresAfter); + } + } + + //Call the dependency indicator to allow for the normal dojo setup. + //Only allow for one dot reference, for the hostenv.* type calls. + var depType = dep[0]; + var objPath = depType.split("."); + if(objPath.length == 2){ + dojo[objPath[0]][objPath[1]].apply(dojo[objPath[0]], dep.slice(1)); + }else{ + dojo[depType].apply(dojo, dep.slice(1)); + } + } + + //Save off the package contents for definition later. + var contentIndex = this.xdContents.push({content: pkg.definePackage, isDefined: false}) - 1; + + //Add provide/requires to dependency map. + for(var i = 0; i < provideList.length; i++){ + this.xdDepMap[provideList[i]] = { requires: requireList, requiresAfter: requireAfterList, contentIndex: contentIndex }; + } + + //Now update the inflight status for any provided packages in this loaded package. + //Do this at the very end (in a *separate* for loop) to avoid shutting down the + //inflight timer check too soon. + for(var i = 0; i < provideList.length; i++){ + this.xdInFlight[provideList[i]] = false; + } + } +} + +dojo.hostenv.xdLoadFlattenedBundle = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*Object*/bundleData){ + //summary: Internal xd loader function. Used when loading + //a flattened localized bundle via a script tag. + locale = locale || "root"; + var jsLoc = dojo.hostenv.normalizeLocale(locale).replace('-', '_'); + var bundlePackage = [moduleName, "nls", bundleName].join("."); + var bundle = dojo.hostenv.startPackage(bundlePackage); + bundle[jsLoc] = bundleData; + + //Assign the bundle for the original locale(s) we wanted. + var mapName = [moduleName, jsLoc, bundleName].join("."); + var bundleMap = dojo.hostenv.xdBundleMap[mapName]; + if(bundleMap){ + for(var param in bundleMap){ + bundle[param] = bundleData; + } + } +}; + + +dojo.hostenv.xdBundleMap = {}; + +dojo.xdRequireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String*/availableFlatLocales){ + //summary: Internal xd loader function. The xd version of dojo.requireLocalization. + var locales = availableFlatLocales.split(","); + + //Find the best-match locale to load. + var jsLoc = dojo.hostenv.normalizeLocale(locale); + + var bestLocale = ""; + for(var i = 0; i < locales.length; i++){ + //Locale must match from start of string. + if(jsLoc.indexOf(locales[i]) == 0){ + if(locales[i].length > bestLocale.length){ + bestLocale = locales[i]; + } + } + } + + var fixedBestLocale = bestLocale.replace('-', '_'); + //See if the bundle we are going to use is already loaded. + var bundlePackage = dojo.evalObjPath([moduleName, "nls", bundleName].join(".")); + if(bundlePackage && bundlePackage[fixedBestLocale]){ + bundle[jsLoc.replace('-', '_')] = bundlePackage[fixedBestLocale]; + }else{ + //Need to remember what locale we wanted and which one we actually use. + //Then when we load the one we are actually using, use that bundle for the one + //we originally wanted. + var mapName = [moduleName, (fixedBestLocale||"root"), bundleName].join("."); + var bundleMap = dojo.hostenv.xdBundleMap[mapName]; + if(!bundleMap){ + bundleMap = dojo.hostenv.xdBundleMap[mapName] = {}; + } + bundleMap[jsLoc.replace('-', '_')] = true; + + //Do just a normal dojo.require so the package tracking stuff works as usual. + dojo.require(moduleName + ".nls" + (bestLocale ? "." + bestLocale : "") + "." + bundleName); + } +} + +;(function(){ + // Simulate the extra locale work that dojo.requireLocalization does. + + var extra = djConfig.extraLocale; + if(extra){ + if(!extra instanceof Array){ + extra = [extra]; + } + + dojo._xdReqLoc = dojo.xdRequireLocalization; + dojo.xdRequireLocalization = function(m, b, locale, fLocales){ + dojo._xdReqLoc(m,b,locale, fLocales); + if(locale){return;} + for(var i=0; i<extra.length; i++){ + dojo._xdReqLoc(m,b,extra[i], fLocales); + } + }; + } +})(); + + +//This is a bit brittle: it has to know about the dojo methods that deal with dependencies +//It would be ideal to intercept the actual methods and do something fancy at that point, +//but I have concern about knowing which provide to match to the dependency in that case, +//since scripts can load whenever they want, and trigger new calls to dojo.hostenv.packageLoaded(). +dojo.hostenv.unpackXdDependency = function(dep){ + //summary: Internal xd loader function. Determines what to do with a dependency + //that was listed in an xd version of a module contents. + + //Extract the dependency(ies). + var newDeps = null; + var newAfterDeps = null; + switch(dep[0]){ + case "requireIf": + case "requireAfterIf": + case "conditionalRequire": + //First arg (dep[1]) is the test. Depedency is dep[2]. + if((dep[1] === true)||(dep[1]=="common")||(dep[1] && dojo.render[dep[1]].capable)){ + newDeps = [{name: dep[2], content: null}]; + } + break; + case "requireAll": + //the arguments are an array, each element a call to require. + //Get rid of first item, which is "requireAll". + dep.shift(); + newDeps = dep; + dojo.hostenv.flattenRequireArray(newDeps); + break; + case "kwCompoundRequire": + case "hostenv.conditionalLoadModule": + var modMap = dep[1]; + var common = modMap["common"]||[]; + var newDeps = (modMap[dojo.hostenv.name_]) ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]); + dojo.hostenv.flattenRequireArray(newDeps); + break; + case "require": + case "requireAfter": + case "hostenv.loadModule": + //Just worry about dep[1] + newDeps = [{name: dep[1], content: null}]; + break; + } + + //The requireAfterIf or requireAfter needs to be evaluated after the current package is evaluated. + if(dep[0] == "requireAfterIf"){ + newAfterDeps = newDeps; + newDeps = null; + } + return {requires: newDeps, requiresAfter: newAfterDeps}; //Object +} + +dojo.hostenv.xdWalkReqs = function(){ + //summary: Internal xd loader function. + //Walks the requires and evaluates package contents in + //the right order. + var reqChain = null; + var req; + for(var i = 0; i < this.xdOrderedReqs.length; i++){ + req = this.xdOrderedReqs[i]; + if(this.xdDepMap[req]){ + reqChain = [req]; + reqChain[req] = true; //Allow for fast lookup of the req in the array + this.xdEvalReqs(reqChain); + } + } +} + +dojo.hostenv.xdTraceReqs = function(/*Object*/reqs, /*Array*/reqChain){ + //summary: Internal xd loader function. + //Trace the requires to chain the correct order of required modules. + if(reqs && reqs.length > 0){ + var nextReq; + for(var i = 0; i < reqs.length; i++){ + nextReq = reqs[i].name; + if(nextReq && !reqChain[nextReq]){ + //New req depedency. Follow it down. + reqChain.push(nextReq); + reqChain[nextReq] = true; + this.xdEvalReqs(reqChain); + } + } + } +} + +dojo.hostenv.xdEvalReqs = function(/*Array*/reqChain){ + //summary: Internal xd loader function. + //Does a depth first, breadth second search and eval of required modules. + if(reqChain.length > 0){ + var req = reqChain[reqChain.length - 1]; + var pkg = this.xdDepMap[req]; + if(pkg){ + //Trace down any requires for this package. + this.xdTraceReqs(pkg.requires, reqChain); + + //Evaluate the package. + var contents = this.xdContents[pkg.contentIndex]; + if(!contents.isDefined){ + //Evaluate the package to bring it into being. + //Pass dojo in so that later, to support multiple versions of dojo + //in a page, we can pass which version of dojo to use. + contents.content(dojo); + contents.isDefined = true; + } + this.xdDepMap[req] = null; + + //Trace down any requireAfters for this package.. + this.xdTraceReqs(pkg.requiresAfter, reqChain); + } + + //Done with that require. Remove it and go to the next one. + reqChain.pop(); + this.xdEvalReqs(reqChain); + } +} + +dojo.hostenv.clearXdInterval = function(){ + //summary: Internal xd loader function. + //Clears the interval timer used to check on the + //status of in-flight xd module resource requests. + clearInterval(this.xdTimer); + this.xdTimer = 0; +} + +dojo.hostenv.watchInFlightXDomain = function(){ + //summary: Internal xd loader function. + //Monitors in-flight requests for xd module resources. + + //Make sure we haven't waited timed out. + var waitInterval = (djConfig.xdWaitSeconds || 30) * 1000; + + if(this.xdStartTime + waitInterval < (new Date()).getTime()){ + this.clearXdInterval(); + var noLoads = ""; + for(var param in this.xdInFlight){ + if(this.xdInFlight[param]){ + noLoads += param + " "; + } + } + dojo.raise("Could not load cross-domain packages: " + noLoads); + } + + //If any are true, then still waiting. + //Come back later. + for(var param in this.xdInFlight){ + if(this.xdInFlight[param]){ + return; + } + } + + //All done loading. Clean up and notify that we are loaded. + this.clearXdInterval(); + + this.xdWalkReqs(); + + //Evaluate any packages that were not evaled before. + //This normally shouldn't happen with proper dojo.provide and dojo.require + //usage, but providing it just in case. Note that these may not be executed + //in the original order that the developer intended. + //Pass dojo in so that later, to support multiple versions of dojo + //in a page, we can pass which version of dojo to use. + for(var i = 0; i < this.xdContents.length; i++){ + var current = this.xdContents[i]; + if(current.content && !current.isDefined){ + current.content(dojo); + } + } + + //Clean up for the next round of xd loading. + this.resetXd(); + + //Clear inflight count so we will finally do finish work. + this.inFlightCount = 0; + this.callLoaded(); +} + +dojo.hostenv.flattenRequireArray = function(/*Array*/target){ + //summary: Internal xd loader function. + //Flattens an array of arrays into a one-level deep array. + + //Each result could be an array of 3 elements (the 3 arguments to dojo.require). + //We only need the first one. + if(target){ + for(var i = 0; i < target.length; i++){ + if(target[i] instanceof Array){ + target[i] = {name: target[i][0], content: null}; + }else{ + target[i] = {name: target[i], content: null}; + } + } + } +} + + +dojo.hostenv.xdHasCalledPreload = false; +dojo.hostenv.xdRealCallLoaded = dojo.hostenv.callLoaded; +dojo.hostenv.callLoaded = function(){ + //summary: Internal xd loader function. Overrides callLoaded() from loader.js + //description: The method is overridden because xd loading needs to preload + //any flattened i18n bundles before dojo starts executing code, + //since xd loading cannot do it synchronously, as the i18n code normally expects. + + //If getModulePrefix for dojo returns anything other than "src", that means + //there is a path registered for dojo, with implies that dojo was xdomain loaded. + if(this.xdHasCalledPreload || dojo.hostenv.getModulePrefix("dojo") == "src" || !this.localesGenerated){ + this.xdRealCallLoaded(); + this.xdHasCalledPreload = true; + }else{ + if(this.localesGenerated){ + this.registerNlsPrefix = function(){ + //Need to set the nls prefix to be the xd location. + dojo.registerModulePath("nls", dojo.hostenv.getModulePrefix("dojo") + "/../nls"); + }; + this.preloadLocalizations(); + } + this.xdHasCalledPreload = true; + } +} Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/loader_xd.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/loader_xd.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/loader_xd.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/ConsoleLogger.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/ConsoleLogger.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/ConsoleLogger.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/ConsoleLogger.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,108 @@ +/* + 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.logging.ConsoleLogger"); +dojo.require("dojo.logging.Logger"); + +dojo.lang.extend(dojo.logging.MemoryLogHandler,{ + + debug:function(){ + dojo.hostenv.println.apply(this,arguments); + }, + info:function(){ + dojo.hostenv.println.apply(this,arguments); + }, + warn:function(){ + dojo.hostenv.println.apply(this,arguments); + }, + error:function(){ + dojo.hostenv.println.apply(this,arguments); + }, + critical:function(){ + dojo.hostenv.println.apply(this,arguments); + }, + + emit:function(record){ + if (!djConfig.isDebug) { return; } + + var funcName=null; + switch(record.level){ + case 1: + funcName="debug"; + break; + case 2: + funcName="info"; + break; + case 3: + funcName="warn"; + break; + case 4: + funcName="error"; + break; + case 5: + funcName="critical"; + break; + default: + funcName="debug"; + } + + var logStr = String(dojo.log.getLevelName(record.level)+": " + +record.time.toLocaleTimeString())+": "+record.message; + if(record.msgArgs && record.msgArgs.length > 0){ + this[funcName].call(this, logStr, record.msgArgs); + } else { + this[funcName].call(this, logStr); + } + + this.data.push(record); + if(this.numRecords != -1){ + while(this.data.length>this.numRecords){ + this.data.shift(); + } + } + } +}); + +if(!dj_undef("console") && !dj_undef("info", console)){ + dojo.lang.extend(dojo.logging.MemoryLogHandler,{ + debug:function(){ + console.debug.apply(this, arguments); + }, + info:function(){ + console.info.apply(this, arguments); + }, + warn:function(){ + console.warn.apply(this, arguments); + }, + error:function(){ + console.error.apply(this, arguments); + }, + critical:function(){ + console.error.apply(this, arguments); + } + }); + + dojo.lang.extend(dojo.logging.Logger,{ + exception: function(msg, e, squelch){ + var args=[msg]; + + if(e){ + msg+=" : "+ e.name + " " + (e.description||e.message); + args.push(e); + } + + this.logType("ERROR", args); + if(!squelch){ + throw e; + } + } + }); + +} Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/ConsoleLogger.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/ConsoleLogger.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/ConsoleLogger.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/Logger.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/Logger.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/Logger.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/Logger.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,474 @@ +/* + 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.logging.Logger"); +dojo.provide("dojo.logging.LogFilter"); +dojo.provide("dojo.logging.Record"); +dojo.provide("dojo.log"); +dojo.require("dojo.lang.common"); +dojo.require("dojo.lang.declare"); + +/* This is the dojo logging facility, which is imported from nWidgets + (written by Alex Russell, CLA on file), which is patterned on the + Python logging module, which in turn has been heavily influenced by + log4j (execpt with some more pythonic choices, which we adopt as well). + + While the dojo logging facilities do provide a set of familiar + interfaces, many of the details are changed to reflect the constraints + of the browser environment. Mainly, file and syslog-style logging + facilites are not provided, with HTTP POST and GET requests being the + only ways of getting data from the browser back to a server. Minimal + support for this (and XML serialization of logs) is provided, but may + not be of practical use in a deployment environment. + + The Dojo logging classes are agnostic of any environment, and while + default loggers are provided for browser-based interpreter + environments, this file and the classes it define are explicitly + designed to be portable to command-line interpreters and other + ECMA-262v3 envrionments. + + the logger needs to accomidate: + log "levels" + type identifiers + file? + message + tic/toc? + + The logger should ALWAYS record: + time/date logged + message + type + level +*/ +// TODO: define DTD for XML-formatted log messages +// TODO: write XML Formatter class +// TODO: write HTTP Handler which uses POST to send log lines/sections + + +dojo.logging.Record = function(/*Integer*/logLevel, /*String||Array*/message){ + // summary: + // A simple data structure class that stores information for and about + // a logged event. Objects of this type are created automatically when + // an event is logged and are the internal format in which information + // about log events is kept. + // logLevel: + // Integer mapped via the dojo.logging.log.levels object from a + // string. This mapping also corresponds to an instance of + // dojo.logging.Logger + // message: + // The contents of the message represented by this log record. + this.level = logLevel; + this.message = ""; + this.msgArgs = []; + this.time = new Date(); + + if(dojo.lang.isArray(message)){ + if(message.length > 0 && dojo.lang.isString(message[0])){ + this.message=message.shift(); + } + this.msgArgs = message; + }else{ + this.message = message; + } + // FIXME: what other information can we receive/discover here? +} + +dojo.logging.LogFilter = function(loggerChain){ + // summary: + // An empty parent (abstract) class which concrete filters should + // inherit from. Filters should have only a single method, filter(), + // which processes a record and returns true or false to denote + // whether or not it should be handled by the next step in a filter + // chain. + this.passChain = loggerChain || ""; + this.filter = function(record){ + // FIXME: need to figure out a way to enforce the loggerChain + // restriction + return true; // pass all records + } +} + +dojo.logging.Logger = function(){ + this.cutOffLevel = 0; + this.propagate = true; + this.parent = null; + // storage for dojo.logging.Record objects seen and accepted by this logger + this.data = []; + this.filters = []; + this.handlers = []; +} + +dojo.extend(dojo.logging.Logger,{ + _argsToArr: function(args){ + var ret = []; + for(var x=0; x<args.length; x++){ + ret.push(args[x]); + } + return ret; + }, + + setLevel: function(/*Integer*/lvl){ + // summary: + // set the logging level for this logger. + // lvl: + // the logging level to set the cutoff for, as derived from the + // dojo.logging.log.levels object. Any messages below the + // specified level are dropped on the floor + this.cutOffLevel = parseInt(lvl); + }, + + isEnabledFor: function(/*Integer*/lvl){ + // summary: + // will a message at the specified level be emitted? + return parseInt(lvl) >= this.cutOffLevel; // boolean + }, + + getEffectiveLevel: function(){ + // summary: + // gets the effective cutoff level, including that of any + // potential parent loggers in the chain. + if((this.cutOffLevel==0)&&(this.parent)){ + return this.parent.getEffectiveLevel(); // Integer + } + return this.cutOffLevel; // Integer + }, + + addFilter: function(/*dojo.logging.LogFilter*/flt){ + // summary: + // registers a new LogFilter object. All records will be passed + // through this filter from now on. + this.filters.push(flt); + return this.filters.length-1; // Integer + }, + + removeFilterByIndex: function(/*Integer*/fltIndex){ + // summary: + // removes the filter at the specified index from the filter + // chain. Returns whether or not removal was successful. + if(this.filters[fltIndex]){ + delete this.filters[fltIndex]; + return true; // boolean + } + return false; // boolean + }, + + removeFilter: function(/*dojo.logging.LogFilter*/fltRef){ + // summary: + // removes the passed LogFilter. Returns whether or not removal + // was successful. + for(var x=0; x<this.filters.length; x++){ + if(this.filters[x]===fltRef){ + delete this.filters[x]; + return true; + } + } + return false; + }, + + removeAllFilters: function(){ + // summary: clobbers all the registered filters. + this.filters = []; // clobber all of them + }, + + filter: function(/*dojo.logging.Record*/rec){ + // summary: + // runs the passed Record through the chain of registered filters. + // Returns a boolean indicating whether or not the Record should + // be emitted. + for(var x=0; x<this.filters.length; x++){ + if((this.filters[x]["filter"])&& + (!this.filters[x].filter(rec))|| + (rec.level<this.cutOffLevel)){ + return false; // boolean + } + } + return true; // boolean + }, + + addHandler: function(/*dojo.logging.LogHandler*/hdlr){ + // summary: adds as LogHandler to the chain + this.handlers.push(hdlr); + return this.handlers.length-1; + }, + + handle: function(/*dojo.logging.Record*/rec){ + // summary: + // if the Record survives filtering, pass it down to the + // registered handlers. Returns a boolean indicating whether or + // not the record was successfully handled. If the message is + // culled for some reason, returns false. + if((!this.filter(rec))||(rec.level<this.cutOffLevel)){ return false; } // boolean + for(var x=0; x<this.handlers.length; x++){ + if(this.handlers[x]["handle"]){ + this.handlers[x].handle(rec); + } + } + // FIXME: not sure what to do about records to be propagated that may have + // been modified by the handlers or the filters at this logger. Should + // parents always have pristine copies? or is passing the modified record + // OK? + // if((this.propagate)&&(this.parent)){ this.parent.handle(rec); } + return true; // boolean + }, + + // the heart and soul of the logging system + log: function(/*integer*/lvl, /*string*/msg){ + // summary: + // log a message at the specified log level + if( (this.propagate)&&(this.parent)&& + (this.parent.rec.level>=this.cutOffLevel)){ + this.parent.log(lvl, msg); + return false; + } + // FIXME: need to call logging providers here! + this.handle(new dojo.logging.Record(lvl, msg)); + return true; + }, + + // logger helpers + debug:function(/*string*/msg){ + // summary: + // log the msg and any other arguments at the "debug" logging + // level. + return this.logType("DEBUG", this._argsToArr(arguments)); + }, + + info: function(msg){ + // summary: + // log the msg and any other arguments at the "info" logging + // level. + return this.logType("INFO", this._argsToArr(arguments)); + }, + + warning: function(msg){ + // summary: + // log the msg and any other arguments at the "warning" logging + // level. + return this.logType("WARNING", this._argsToArr(arguments)); + }, + + error: function(msg){ + // summary: + // log the msg and any other arguments at the "error" logging + // level. + return this.logType("ERROR", this._argsToArr(arguments)); + }, + + critical: function(msg){ + // summary: + // log the msg and any other arguments at the "critical" logging + // level. + return this.logType("CRITICAL", this._argsToArr(arguments)); + }, + + exception: function(/*string*/msg, /*Error*/e, /*boolean*/squelch){ + // summary: + // logs the error and the message at the "exception" logging + // level. If squelch is true, also prevent bubbling of the + // exception. + + // FIXME: this needs to be modified to put the exception in the msg + // if we're on Moz, we can get the following from the exception object: + // lineNumber + // message + // fileName + // stack + // name + // on IE, we get: + // name + // message (from MDA?) + // number + // description (same as message!) + if(e){ + var eparts = [e.name, (e.description||e.message)]; + if(e.fileName){ + eparts.push(e.fileName); + eparts.push("line "+e.lineNumber); + // eparts.push(e.stack); + } + msg += " "+eparts.join(" : "); + } + + this.logType("ERROR", msg); + if(!squelch){ + throw e; + } + }, + + logType: function(/*string*/type, /*array*/args){ + // summary: + // a more "user friendly" version of the log() function. Takes the + // named log level instead of the corresponding integer. + return this.log.apply(this, [dojo.logging.log.getLevel(type), + args]); + }, + + warn:function(){ + // summary: shorthand for warning() + this.warning.apply(this,arguments); + }, + err:function(){ + // summary: shorthand for error() + this.error.apply(this,arguments); + }, + crit:function(){ + // summary: shorthand for critical() + this.critical.apply(this,arguments); + } +}); + +// the Handler class +dojo.logging.LogHandler = function(level){ + this.cutOffLevel = (level) ? level : 0; + this.formatter = null; // FIXME: default formatter? + this.data = []; + this.filters = []; +} +dojo.lang.extend(dojo.logging.LogHandler,{ + + setFormatter:function(formatter){ + dojo.unimplemented("setFormatter"); + }, + + flush:function(){ + // summary: + // Unimplemented. Should be implemented by subclasses to handle + // finishing a transaction or otherwise comitting pending log + // messages to whatevery underlying transport or storage system is + // available. + }, + close:function(){ + // summary: + // Unimplemented. Should be implemented by subclasses to handle + // shutting down the logger, including a call to flush() + }, + handleError:function(){ + // summary: + // Unimplemented. Should be implemented by subclasses. + dojo.deprecated("dojo.logging.LogHandler.handleError", "use handle()", "0.6"); + }, + + handle:function(/*dojo.logging.Record*/record){ + // summary: + // Emits the record object passed in should the record meet the + // current logging level cuttof, as specified in cutOffLevel. + if((this.filter(record))&&(record.level>=this.cutOffLevel)){ + this.emit(record); + } + }, + + emit:function(/*dojo.logging.Record*/record){ + // summary: + // Unimplemented. Should be implemented by subclasses to handle + // an individual record. Subclasses may batch records and send + // them to their "substrate" only when flush() is called, but this + // is generally not a good idea as losing logging messages may + // make debugging significantly more difficult. Tuning the volume + // of logging messages written to storage should be accomplished + // with log levels instead. + dojo.unimplemented("emit"); + } +}); + +// set aliases since we don't want to inherit from dojo.logging.Logger +void(function(){ // begin globals protection closure + var names = [ + "setLevel", "addFilter", "removeFilterByIndex", "removeFilter", + "removeAllFilters", "filter" + ]; + var tgt = dojo.logging.LogHandler.prototype; + var src = dojo.logging.Logger.prototype; + for(var x=0; x<names.length; x++){ + tgt[names[x]] = src[names[x]]; + } +})(); // end globals protection closure + +dojo.logging.log = new dojo.logging.Logger(); + +// an associative array of logger objects. This object inherits from +// a list of level names with their associated numeric levels +dojo.logging.log.levels = [ {"name": "DEBUG", "level": 1}, + {"name": "INFO", "level": 2}, + {"name": "WARNING", "level": 3}, + {"name": "ERROR", "level": 4}, + {"name": "CRITICAL", "level": 5} ]; + +dojo.logging.log.loggers = {}; + +dojo.logging.log.getLogger = function(/*string*/name){ + // summary: + // returns a named dojo.logging.Logger instance. If one is not already + // available with that name in the global map, one is created and + // returne. + if(!this.loggers[name]){ + this.loggers[name] = new dojo.logging.Logger(); + this.loggers[name].parent = this; + } + return this.loggers[name]; // dojo.logging.Logger +} + +dojo.logging.log.getLevelName = function(/*integer*/lvl){ + // summary: turns integer logging level into a human-friendly name + for(var x=0; x<this.levels.length; x++){ + if(this.levels[x].level == lvl){ + return this.levels[x].name; // string + } + } + return null; +} + +dojo.logging.log.getLevel = function(/*string*/name){ + // summary: name->integer conversion for log levels + for(var x=0; x<this.levels.length; x++){ + if(this.levels[x].name.toUpperCase() == name.toUpperCase()){ + return this.levels[x].level; // integer + } + } + return null; +} + +// a default handler class, it simply saves all of the handle()'d records in +// memory. Useful for attaching to with dojo.event.connect() + +dojo.declare("dojo.logging.MemoryLogHandler", + dojo.logging.LogHandler, + { + initializer: function(level, recordsToKeep, postType, postInterval){ + // mixin style inheritance + dojo.logging.LogHandler.call(this, level); + // default is unlimited + this.numRecords = (typeof djConfig['loggingNumRecords'] != 'undefined') ? djConfig['loggingNumRecords'] : ((recordsToKeep) ? recordsToKeep : -1); + // 0=count, 1=time, -1=don't post TODO: move this to a better location for prefs + this.postType = (typeof djConfig['loggingPostType'] != 'undefined') ? djConfig['loggingPostType'] : ( postType || -1); + // milliseconds for time, interger for number of records, -1 for non-posting, + this.postInterval = (typeof djConfig['loggingPostInterval'] != 'undefined') ? djConfig['loggingPostInterval'] : ( postType || -1); + }, + emit: function(record){ + if(!djConfig.isDebug){ return; } + var logStr = String(dojo.log.getLevelName(record.level)+": " + +record.time.toLocaleTimeString())+": "+record.message; + if(!dj_undef("println", dojo.hostenv)){ + dojo.hostenv.println(logStr, record.msgArgs); + } + + this.data.push(record); + if(this.numRecords != -1){ + while(this.data.length>this.numRecords){ + this.data.shift(); + } + } + } + } +); + +dojo.logging.logQueueHandler = new dojo.logging.MemoryLogHandler(0,50,0,10000); + +dojo.logging.log.addHandler(dojo.logging.logQueueHandler); +dojo.log = dojo.logging.log; Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/Logger.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/Logger.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/Logger.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/__package__.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/__package__.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/__package__.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/__package__.js Mon Feb 19 09:56:06 2007 @@ -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.logging.Logger", false, false]], + rhino: ["dojo.logging.RhinoLogger"] +}); +dojo.provide("dojo.logging.*"); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/__package__.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/__package__.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/logging/__package__.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/math.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/math.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/math.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/math.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,127 @@ +/* + 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.math"); + +dojo.math.degToRad = function(/* float */x) { + // summary + // Converts degrees to radians. + return (x*Math.PI) / 180; // float +} +dojo.math.radToDeg = function(/* float */x) { + // summary + // Converts radians to degrees. + return (x*180) / Math.PI; // float +} + +dojo.math.factorial = function(/* integer */n){ + // summary + // Returns n! + if(n<1){ return 0; } + var retVal = 1; + for(var i=1;i<=n;i++){ retVal *= i; } + return retVal; // integer +} + +dojo.math.permutations = function(/* integer */n, /* integer */k) { + // summary + // The number of ways of obtaining an ordered subset of k elements from a set of n elements + if(n==0 || k==0) return 1; + return (dojo.math.factorial(n) / dojo.math.factorial(n-k)); // float +} + +dojo.math.combinations = function (/* integer */n, /* integer */r) { + // summary + // The number of ways of picking n unordered outcomes from r possibilities + if(n==0 || r==0) return 1; + return (dojo.math.factorial(n) / (dojo.math.factorial(n-r) * dojo.math.factorial(r))); // float +} + +dojo.math.bernstein = function(/* float */t, /* float */n, /* float */i) { + // summary + // Calculates a weighted average based on the Bernstein theorem. + return (dojo.math.combinations(n,i) * Math.pow(t,i) * Math.pow(1-t,n-i)); // float +} + +dojo.math.gaussianRandom = function(){ + // summary + // Returns random numbers with a Gaussian distribution, with the mean set at 0 and the variance set at 1. + var k = 2; + do { + var i = 2 * Math.random() - 1; + var j = 2 * Math.random() - 1; + k = i * i + j * j; + } while (k >= 1); + k = Math.sqrt((-2 * Math.log(k)) / k); + return i * k; // float +} + +dojo.math.mean = function() { + // summary + // Calculates the mean of an Array of numbers. + var array = dojo.lang.isArray(arguments[0]) ? arguments[0] : arguments; + var mean = 0; + for (var i = 0; i < array.length; i++) { mean += array[i]; } + return mean / array.length; // float +} + +dojo.math.round = function(/* float */number, /* integer */places) { + // summary + // Extends Math.round by adding a second argument specifying the number of decimal places to round to. + // TODO: add support for significant figures + if (!places) { var shift = 1; } + else { var shift = Math.pow(10, places); } + return Math.round(number * shift) / shift; // float +} + +dojo.math.sd = dojo.math.standardDeviation = function(/* array */){ + // summary + // Calculates the standard deviation of an Array of numbers + var array = dojo.lang.isArray(arguments[0]) ? arguments[0] : arguments; + return Math.sqrt(dojo.math.variance(array)); // float +} + +dojo.math.variance = function(/* array */) { + // summary + // Calculates the variance of an Array of numbers + var array = dojo.lang.isArray(arguments[0]) ? arguments[0] : arguments; + var mean = 0, squares = 0; + for (var i = 0; i < array.length; i++) { + mean += array[i]; + squares += Math.pow(array[i], 2); + } + return (squares / array.length) - Math.pow(mean / array.length, 2); // float +} + +dojo.math.range = function(/* integer */a, /* integer */b, /* integer */step) { + // summary + // implementation of Python's range() + if(arguments.length < 2) { + b = a; + a = 0; + } + if(arguments.length < 3) { + step = 1; + } + + var range = []; + if(step > 0) { + for(var i = a; i < b; i += step) { + range.push(i); + } + } else if(step < 0) { + for(var i = a; i > b; i += step) { + range.push(i); + } + } else { + throw new Error("dojo.math.range: step must be non-zero"); + } + return range; // array +} Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/math.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/math.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/math.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/math/__package__.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/math/__package__.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/math/__package__.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/math/__package__.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,18 @@ +/* + 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.math", false, false], + ["dojo.math.curves", false, false], + ["dojo.math.points", false, false] + ] +}); +dojo.provide("dojo.math.*"); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/math/__package__.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/math/__package__.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/math/__package__.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/math/curves.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/math/curves.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/math/curves.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/math/curves.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,242 @@ +/* + 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.math.curves"); +dojo.require("dojo.math"); + +/* Curves from Dan's 13th lib stuff. + * See: http://pupius.co.uk/js/Toolkit.Drawing.js + * http://pupius.co.uk/dump/dojo/Dojo.Math.js + */ + +dojo.math.curves = { + Line: function(/* array */start, /* array */end) { + // summary + // Creates a straight line object + this.start = start; + this.end = end; + this.dimensions = start.length; + + for(var i = 0; i < start.length; i++) { + start[i] = Number(start[i]); + } + + for(var i = 0; i < end.length; i++) { + end[i] = Number(end[i]); + } + + //simple function to find point on an n-dimensional, straight line + this.getValue = function(/* float */n){ + // summary + // Returns the point at point N (in terms of percentage) on this line. + var retVal = new Array(this.dimensions); + for(var i=0;i<this.dimensions;i++) + retVal[i] = ((this.end[i] - this.start[i]) * n) + this.start[i]; + return retVal; // array + } + return this; // dojo.math.curves.Line + }, + + Bezier: function(/* array */pnts) { + // summary + // Creates a bezier curve + // Takes an array of points, the first is the start point, the last is end point and the ones in + // between are the Bezier control points. + this.getValue = function(/* float */step) { + // summary + // Returns the point at point N (in terms of percentage) on this curve. + if(step >= 1) return this.p[this.p.length-1]; // if step>=1 we must be at the end of the curve + if(step <= 0) return this.p[0]; // if step<=0 we must be at the start of the curve + var retVal = new Array(this.p[0].length); + for(var k=0;j<this.p[0].length;k++) { retVal[k]=0; } + for(var j=0;j<this.p[0].length;j++) { + var C=0; var D=0; + for(var i=0;i<this.p.length;i++) { + C += this.p[i][j] * this.p[this.p.length-1][0] + * dojo.math.bernstein(step,this.p.length,i); + } + for(var l=0;l<this.p.length;l++) { + D += this.p[this.p.length-1][0] * dojo.math.bernstein(step,this.p.length,l); + } + retVal[j] = C/D; + } + return retVal; // array + } + this.p = pnts; + return this; // dojo.math.curves.Bezier + }, + + CatmullRom : function(/* array */pnts, /* float */c) { + // summary + // Creates a catmull-rom spline curve with c tension. + this.getValue = function(/* float */step) { + // summary + // Returns the point at point N (in terms of percentage) on this curve. + var percent = step * (this.p.length-1); + var node = Math.floor(percent); + var progress = percent - node; + + var i0 = node-1; if(i0 < 0) i0 = 0; + var i = node; + var i1 = node+1; if(i1 >= this.p.length) i1 = this.p.length-1; + var i2 = node+2; if(i2 >= this.p.length) i2 = this.p.length-1; + + var u = progress; + var u2 = progress*progress; + var u3 = progress*progress*progress; + + var retVal = new Array(this.p[0].length); + for(var k=0;k<this.p[0].length;k++) { + var x1 = ( -this.c * this.p[i0][k] ) + ( (2 - this.c) * this.p[i][k] ) + ( (this.c-2) * this.p[i1][k] ) + ( this.c * this.p[i2][k] ); + var x2 = ( 2 * this.c * this.p[i0][k] ) + ( (this.c-3) * this.p[i][k] ) + ( (3 - 2 * this.c) * this.p[i1][k] ) + ( -this.c * this.p[i2][k] ); + var x3 = ( -this.c * this.p[i0][k] ) + ( this.c * this.p[i1][k] ); + var x4 = this.p[i][k]; + + retVal[k] = x1*u3 + x2*u2 + x3*u + x4; + } + return retVal; // array + } + + if(!c) this.c = 0.7; + else this.c = c; + this.p = pnts; + + return this; // dojo.math.curves.CatmullRom + }, + + // FIXME: This is the bad way to do a partial-arc with 2 points. We need to have the user + // supply the radius, otherwise we always get a half-circle between the two points. + Arc : function(/* array */start, /* array */end, /* boolean? */ccw) { + // summary + // Creates an arc with a counter clockwise switch + var center = dojo.math.points.midpoint(start, end); + var sides = dojo.math.points.translate(dojo.math.points.invert(center), start); + var rad = Math.sqrt(Math.pow(sides[0], 2) + Math.pow(sides[1], 2)); + var theta = dojo.math.radToDeg(Math.atan(sides[1]/sides[0])); + if( sides[0] < 0 ) { + theta -= 90; + } else { + theta += 90; + } + dojo.math.curves.CenteredArc.call(this, center, rad, theta, theta+(ccw?-180:180)); + }, + + CenteredArc : function(/* array */center, /* float */radius, /* array */start, /* array */end) { + // summary + // Creates an arc object, with center and radius (Top of arc = 0 degrees, increments clockwise) + // center => 2D point for center of arc + // radius => scalar quantity for radius of arc + // start => to define an arc specify start angle (default: 0) + // end => to define an arc specify start angle + this.center = center; + this.radius = radius; + this.start = start || 0; + this.end = end; + + this.getValue = function(/* float */n) { + // summary + // Returns the point at point N (in terms of percentage) on this curve. + var retVal = new Array(2); + var theta = dojo.math.degToRad(this.start+((this.end-this.start)*n)); + + retVal[0] = this.center[0] + this.radius*Math.sin(theta); + retVal[1] = this.center[1] - this.radius*Math.cos(theta); + + return retVal; // array + } + + return this; // dojo.math.curves.CenteredArc + }, + + Circle : function(/* array */center, /* float */radius) { + // summary + // Special case of Arc (start = 0, end = 360) + dojo.math.curves.CenteredArc.call(this, center, radius, 0, 360); + return this; // dojo.math.curves.Circle + }, + + Path : function() { + // summary + // Generic path shape, created from curve segments + var curves = []; + var weights = []; + var ranges = []; + var totalWeight = 0; + + this.add = function(/* dojo.math.curves.* */curve, /* float */weight) { + // summary + // Add a curve segment to this path + if( weight < 0 ) { dojo.raise("dojo.math.curves.Path.add: weight cannot be less than 0"); } + curves.push(curve); + weights.push(weight); + totalWeight += weight; + computeRanges(); + } + + this.remove = function(/* dojo.math.curves.* */curve) { + // summary + // Remove a curve segment from this path + for(var i = 0; i < curves.length; i++) { + if( curves[i] == curve ) { + curves.splice(i, 1); + totalWeight -= weights.splice(i, 1)[0]; + break; + } + } + computeRanges(); + } + + this.removeAll = function() { + // summary + // Remove all curve segments + curves = []; + weights = []; + totalWeight = 0; + } + + this.getValue = function(/* float */n) { + // summary + // Returns the point at point N (in terms of percentage) on this curve. + var found = false, value = 0; + for(var i = 0; i < ranges.length; i++) { + var r = ranges[i]; + //w(r.join(" ... ")); + if( n >= r[0] && n < r[1] ) { + var subN = (n - r[0]) / r[2]; + value = curves[i].getValue(subN); + found = true; + break; + } + } + + // FIXME: Do we want to assume we're at the end? + if( !found ) { + value = curves[curves.length-1].getValue(1); + } + + for(var j = 0; j < i; j++) { + value = dojo.math.points.translate(value, curves[j].getValue(1)); + } + return value; // array + } + + function computeRanges() { + var start = 0; + for(var i = 0; i < weights.length; i++) { + var end = start + weights[i] / totalWeight; + var len = end - start; + ranges[i] = [start, end, len]; + start = end; + } + } + + return this; // dojo.math.curves.Path + } +}; Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/math/curves.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/math/curves.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/math/curves.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/math/matrix.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/math/matrix.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/math/matrix.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/math/matrix.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,377 @@ +/* + 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.math.matrix"); + +// some of this code is based on +// http://www.mkaz.com/math/MatrixCalculator.java +// (published under a BSD Open Source License) +// +// the rest is from my vague memory of matricies in school [cal] +// +// the copying of arguments is a little excessive, and could be trimmed back in +// the case where a function doesn't modify them at all (but some do!) +// +// 2006-06-25: Some enhancements submitted by Erel Segal: +// * addition: a tolerance constant for determinant calculations. +// * performance fix: removed unnecessary argument copying. +// * addition: function "product" for multiplying more than 2 matrices +// * addition: function "sum" for adding any number of matrices +// * bug fix: inversion of a 1x1 matrix without using the adjoint +// * performance fixes: upperTriangle +// * addition: argument "value" to function create, to initialize the matrix with a custom val +// * addition: functions "ones" and "zeros" - like Matlab[TM] functions with the same name. +// * addition: function "identity" for creating an identity matrix of a given size. +// * addition: argument "decimal_points" to function format +// * bug fix: adjoint of a 0-size matrix +// * performance fixes: adjoint +// + +dojo.math.matrix.iDF = 0; + +// Erel: values lower than this value are considered zero (in detereminant calculations). +// It is analogous to Maltab[TM]'s "eps". +dojo.math.matrix.ALMOST_ZERO = 1e-10; +dojo.math.matrix.multiply = function(a, b){ + var ay = a.length; + var ax = a[0].length; + var by = b.length; + var bx = b[0].length; + + if (ax != by){ + dojo.debug("Can't multiply matricies of sizes "+ax+','+ay+' and '+bx+','+by); + return [[0]]; + } + + var c = []; + for(var k=0; k<ay; k++){ + c[k] = []; + for(var i=0; i<bx; i++){ + c[k][i] = 0; + for(var m=0; m<ax; m++){ + c[k][i] += a[k][m]*b[m][i]; + } + } + } + return c; +} + +// Erel: added a "product" function to calculate product of more than 2 matrices: +dojo.math.matrix.product = function() { + if (arguments.length==0) { + dojo.debug ("can't multiply 0 matrices!"); + return 1; + } + var result = arguments[0]; + for (var i=1; i<arguments.length; i++){ + result = dojo.math.matrix.multiply(result,arguments[i]); + } + return result; +} + +// Erel: added a "sum" function to calculate sum of more than 2 matrices: +dojo.math.matrix.sum = function() { + if (arguments.length==0) { + dojo.debug ("can't sum 0 matrices!"); + return 0; + } + var result = dojo.math.matrix.copy(arguments[0]); + var rows = result.length; + if (rows==0) { + dojo.debug ("can't deal with matrices of 0 rows!"); + return 0; + } + var cols = result[0].length; + if (cols==0) { + dojo.debug ("can't deal with matrices of 0 cols!"); + return 0; + } + for (var i=1; i<arguments.length; ++i) { + var arg = arguments[i]; + if (arg.length!=rows || arg[0].length!=cols) { + dojo.debug ("can't add matrices of different dimensions: first dimensions were " + rows + "x" + cols + ", current dimensions are "+arg.length + "x" + arg[0].length); + return 0; + } + + // The actual addition: + for (var r=0; r<rows; r++){ + for (var c=0; c<cols; c++){ + result[r][c] += arg[r][c]; + } + } + } + return result; +} + + +dojo.math.matrix.inverse = function(a){ + // Erel: added special case: inverse of a 1x1 matrix can't be calculated by adjoint + if (a.length==1 && a[0].length==1){ + return [[ 1 / a[0][0] ]]; + } + + // Formula used to Calculate Inverse: + // inv(A) = 1/det(A) * adj(A) + + var tms = a.length; + var m = dojo.math.matrix.create(tms, tms); + var mm = dojo.math.matrix.adjoint(a); + var det = dojo.math.matrix.determinant(a); + var dd = 0; + + if(det == 0){ + dojo.debug("Determinant Equals 0, Not Invertible."); + return [[0]]; + }else{ + dd = 1 / det; + } + + for (var i = 0; i < tms; i++){ + for (var j = 0; j < tms; j++) { + m[i][j] = dd * mm[i][j]; + } + } + return m; +} + +dojo.math.matrix.determinant = function(a){ + if (a.length != a[0].length){ + dojo.debug("Can't calculate the determiant of a non-squre matrix!"); + return 0; + } + + var tms = a.length; + var det = 1; + var b = dojo.math.matrix.upperTriangle(a); + + for (var i=0; i < tms; i++){ + var bii = b[i][i]; + if (Math.abs(bii) < dojo.math.matrix.ALMOST_ZERO){ + return 0; + } + det *= bii; + } + det = det * dojo.math.matrix.iDF; + return det; +} + +dojo.math.matrix.upperTriangle = function(m){ + m = dojo.math.matrix.cop |
«
Return to OFBiz - Commits
|
1 view|%1 views
| Free forum by Nabble | Edit this page |