You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@struts.apache.org by he...@apache.org on 2006/11/13 23:55:14 UTC
svn commit: r474551 [25/49] - in
/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo:
./ src/ src/alg/ src/animation/ src/cal/ src/charting/ src/charting/svg/
src/charting/vml/ src/collections/ src/crypto/ src/data/ src/data/cs...
Added: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/loader.js
URL: http://svn.apache.org/viewvc/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/loader.js?view=auto&rev=474551
==============================================================================
--- struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/loader.js (added)
+++ struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/loader.js Mon Nov 13 14:54:45 2006
@@ -0,0 +1,727 @@
+/*
+ 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
+*/
+
+/*
+ * loader.js - A bootstrap module. Runs before the hostenv_*.js file. Contains all of the package loading methods.
+ */
+
+//A semi-colon is at the start of the line because after doing a build, this function definition
+//get compressed onto the same line as the last line in bootstrap1.js. That list line is just a
+//curly bracket, and the browser complains about that syntax. The semicolon fixes it. Putting it
+//here instead of at the end of bootstrap1.js, since it is more of an issue for this file, (using
+//the closure), and bootstrap1.js could change in the future.
+;(function(){
+ //Additional properties for dojo.hostenv
+ var _addHostEnv = {
+ pkgFileName: "__package__",
+
+ // for recursion protection
+ loading_modules_: {},
+ loaded_modules_: {},
+ addedToLoadingCount: [],
+ removedFromLoadingCount: [],
+
+ inFlightCount: 0,
+
+ // FIXME: it should be possible to pull module prefixes in from djConfig
+ modulePrefixes_: {
+ dojo: {name: "dojo", value: "src"}
+ },
+
+ setModulePrefix: function(/*String*/module, /*String*/prefix){
+ // summary: establishes module/prefix pair
+ this.modulePrefixes_[module] = {name: module, value: prefix};
+ },
+
+ moduleHasPrefix: function(/*String*/module){
+ // summary: checks to see if module has been established
+ var mp = this.modulePrefixes_;
+ return Boolean(mp[module] && mp[module].value); // Boolean
+ },
+
+ getModulePrefix: function(/*String*/module){
+ // summary: gets the prefix associated with module
+ if(this.moduleHasPrefix(module)){
+ return this.modulePrefixes_[module].value; // String
+ }
+ return module; // String
+ },
+
+ getTextStack: [],
+ loadUriStack: [],
+ loadedUris: [],
+
+ //WARNING: This variable is referenced by packages outside of bootstrap: FloatingPane.js and undo/browser.js
+ post_load_: false,
+
+ //Egad! Lots of test files push on this directly instead of using dojo.addOnLoad.
+ modulesLoadedListeners: [],
+ unloadListeners: [],
+ loadNotifying: false
+ };
+
+ //Add all of these properties to dojo.hostenv
+ for(var param in _addHostEnv){
+ dojo.hostenv[param] = _addHostEnv[param];
+ }
+})();
+
+dojo.hostenv.loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){
+// summary:
+// Load a Javascript module given a relative path
+//
+// description:
+// Loads and interprets the script located at relpath, which is relative to the
+// script root directory. If the script is found but its interpretation causes
+// a runtime exception, that exception is not caught by us, so the caller will
+// see it. We return a true value if and only if the script is found.
+//
+// For now, we do not have an implementation of a true search path. We
+// consider only the single base script uri, as returned by getBaseScriptUri().
+//
+// relpath: A relative path to a script (no leading '/', and typically
+// ending in '.js').
+// module: A module whose existance to check for after loading a path.
+// Can be used to determine success or failure of the load.
+// cb: a callback function to pass the result of evaluating the script
+
+ var uri;
+ if(relpath.charAt(0) == '/' || relpath.match(/^\w+:/)){
+ // dojo.raise("relpath '" + relpath + "'; must be relative");
+ uri = relpath;
+ }else{
+ uri = this.getBaseScriptUri() + relpath;
+ }
+ if(djConfig.cacheBust && dojo.render.html.capable){
+ uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,"");
+ }
+ try{
+ return !module ? this.loadUri(uri, cb) : this.loadUriAndCheck(uri, module, cb); // Boolean
+ }catch(e){
+ dojo.debug(e);
+ return false; // Boolean
+ }
+}
+
+dojo.hostenv.loadUri = function(/*String (URL)*/uri, /*Function?*/cb){
+// summary:
+// Loads JavaScript from a URI
+//
+// description:
+// Reads the contents of the URI, and evaluates the contents. This is used to load modules as well
+// as resource bundles. Returns true if it succeeded. Returns false if the URI reading failed.
+// Throws if the evaluation throws.
+//
+// uri: a uri which points at the script to be loaded
+// cb: a callback function to process the result of evaluating the script as an expression, typically
+// used by the resource bundle loader to load JSON-style resources
+
+ if(this.loadedUris[uri]){
+ return true; // Boolean
+ }
+ var contents = this.getText(uri, null, true);
+ if(!contents){ return false; } // Boolean
+ this.loadedUris[uri] = true;
+ if(cb){ contents = '('+contents+')'; }
+ var value = dj_eval(contents);
+ if(cb){ cb(value); }
+ return true; // Boolean
+}
+
+// FIXME: probably need to add logging to this method
+dojo.hostenv.loadUriAndCheck = function(/*String (URL)*/uri, /*String*/moduleName, /*Function?*/cb){
+ // summary: calls loadUri then findModule and returns true if both succeed
+ var ok = true;
+ try{
+ ok = this.loadUri(uri, cb);
+ }catch(e){
+ dojo.debug("failed loading ", uri, " with error: ", e);
+ }
+ return Boolean(ok && this.findModule(moduleName, false)); // Boolean
+}
+
+dojo.loaded = function(){ }
+dojo.unloaded = function(){ }
+
+dojo.hostenv.loaded = function(){
+ this.loadNotifying = true;
+ this.post_load_ = true;
+ var mll = this.modulesLoadedListeners;
+ for(var x=0; x<mll.length; x++){
+ mll[x]();
+ }
+
+ //Clear listeners so new ones can be added
+ //For other xdomain package loads after the initial load.
+ this.modulesLoadedListeners = [];
+ this.loadNotifying = false;
+
+ dojo.loaded();
+}
+
+dojo.hostenv.unloaded = function(){
+ var mll = this.unloadListeners;
+ while(mll.length){
+ (mll.pop())();
+ }
+ dojo.unloaded();
+}
+
+dojo.addOnLoad = function(/*Object?*/obj, /*String|Function*/functionName) {
+// summary:
+// Registers a function to be triggered after the DOM has finished loading
+// and widgets declared in markup have been instantiated. Images and CSS files
+// may or may not have finished downloading when the specified function is called.
+// (Note that widgets' CSS and HTML code is guaranteed to be downloaded before said
+// widgets are instantiated.)
+//
+// usage:
+// dojo.addOnLoad(functionPointer)
+// dojo.addOnLoad(object, "functionName")
+
+ var dh = dojo.hostenv;
+ if(arguments.length == 1) {
+ dh.modulesLoadedListeners.push(obj);
+ } else if(arguments.length > 1) {
+ dh.modulesLoadedListeners.push(function() {
+ obj[functionName]();
+ });
+ }
+
+ //Added for xdomain loading. dojo.addOnLoad is used to
+ //indicate callbacks after doing some dojo.require() statements.
+ //In the xdomain case, if all the requires are loaded (after initial
+ //page load), then immediately call any listeners.
+ if(dh.post_load_ && dh.inFlightCount == 0 && !dh.loadNotifying){
+ dh.callLoaded();
+ }
+}
+
+dojo.addOnUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
+// summary: registers a function to be triggered when the page unloads
+//
+// usage:
+// dojo.addOnLoad(functionPointer)
+// dojo.addOnLoad(object, "functionName")
+ var dh = dojo.hostenv;
+ if(arguments.length == 1){
+ dh.unloadListeners.push(obj);
+ } else if(arguments.length > 1) {
+ dh.unloadListeners.push(function() {
+ obj[functionName]();
+ });
+ }
+}
+
+dojo.hostenv.modulesLoaded = function(){
+ if(this.post_load_){ return; }
+ if(this.loadUriStack.length==0 && this.getTextStack.length==0){
+ if(this.inFlightCount > 0){
+ dojo.debug("files still in flight!");
+ return;
+ }
+ dojo.hostenv.callLoaded();
+ }
+}
+
+dojo.hostenv.callLoaded = function(){
+ if(typeof setTimeout == "object"){
+ setTimeout("dojo.hostenv.loaded();", 0);
+ }else{
+ dojo.hostenv.loaded();
+ }
+}
+
+dojo.hostenv.getModuleSymbols = function(/*String*/modulename){
+// summary:
+// Converts a module name in dotted JS notation to an array representing the path in the source tree
+
+ var syms = modulename.split(".");
+ for(var i = syms.length; i>0; i--){
+ var parentModule = syms.slice(0, i).join(".");
+ if ((i==1) && !this.moduleHasPrefix(parentModule)){
+ //Support default module directory (sibling of dojo)
+ syms[0] = "../" + syms[0];
+ }else{
+ var parentModulePath = this.getModulePrefix(parentModule);
+ if(parentModulePath != parentModule){
+ syms.splice(0, i, parentModulePath);
+ break;
+ }
+ }
+ }
+ return syms; // Array
+}
+
+dojo.hostenv._global_omit_module_check = false;
+dojo.hostenv.loadModule = function(/*String*/moduleName, /*Boolean?*/exactOnly, /*Boolean?*/omitModuleCheck){
+// summary:
+// loads a Javascript module from the appropriate URI
+//
+// description:
+// loadModule("A.B") first checks to see if symbol A.B is defined.
+// If it is, it is simply returned (nothing to do).
+//
+// If it is not defined, it will look for "A/B.js" in the script root directory,
+// followed by "A.js".
+//
+// It throws if it cannot find a file to load, or if the symbol A.B is not
+// defined after loading.
+//
+// It returns the object A.B.
+//
+// This does nothing about importing symbols into the current package.
+// It is presumed that the caller will take care of that. For example, to import
+// all symbols:
+//
+// with (dojo.hostenv.loadModule("A.B")) {
+// ...
+// }
+//
+// And to import just the leaf symbol:
+//
+// var B = dojo.hostenv.loadModule("A.B");
+// ...
+//
+// dj_load is an alias for dojo.hostenv.loadModule
+
+ if(!moduleName){ return; }
+ omitModuleCheck = this._global_omit_module_check || omitModuleCheck;
+ var module = this.findModule(moduleName, false);
+ if(module){
+ return module;
+ }
+
+ // protect against infinite recursion from mutual dependencies
+ if(dj_undef(moduleName, this.loading_modules_)){
+ this.addedToLoadingCount.push(moduleName);
+ }
+ this.loading_modules_[moduleName] = 1;
+
+ // convert periods to slashes
+ var relpath = moduleName.replace(/\./g, '/') + '.js';
+
+ var nsyms = moduleName.split(".");
+
+ // this line allowed loading of a module manifest as if it were a namespace
+ // it's an interesting idea, but shouldn't be combined with 'namespaces' proper
+ // and leads to unwanted dependencies
+ // the effect can be achieved in other (albeit less-flexible) ways now, so I am
+ // removing this pending further design work
+ // perhaps we can explicitly define this idea of a 'module manifest', and subclass
+ // 'namespace manifest' from that
+ //dojo.getNamespace(nsyms[0]);
+
+ var syms = this.getModuleSymbols(moduleName);
+ var startedRelative = ((syms[0].charAt(0) != '/') && !syms[0].match(/^\w+:/));
+ var last = syms[syms.length - 1];
+ var ok;
+ // figure out if we're looking for a full package, if so, we want to do
+ // things slightly diffrently
+ if(last=="*"){
+ moduleName = nsyms.slice(0, -1).join('.');
+ while(syms.length){
+ syms.pop();
+ syms.push(this.pkgFileName);
+ relpath = syms.join("/") + '.js';
+ if(startedRelative && relpath.charAt(0)=="/"){
+ relpath = relpath.slice(1);
+ }
+ ok = this.loadPath(relpath, !omitModuleCheck ? moduleName : null);
+ if(ok){ break; }
+ syms.pop();
+ }
+ }else{
+ relpath = syms.join("/") + '.js';
+ moduleName = nsyms.join('.');
+ var modArg = !omitModuleCheck ? moduleName : null;
+ ok = this.loadPath(relpath, modArg);
+ if(!ok && !exactOnly){
+ syms.pop();
+ while(syms.length){
+ relpath = syms.join('/') + '.js';
+ ok = this.loadPath(relpath, modArg);
+ if(ok){ break; }
+ syms.pop();
+ relpath = syms.join('/') + '/'+this.pkgFileName+'.js';
+ if(startedRelative && relpath.charAt(0)=="/"){
+ relpath = relpath.slice(1);
+ }
+ ok = this.loadPath(relpath, modArg);
+ if(ok){ break; }
+ }
+ }
+
+ if(!ok && !omitModuleCheck){
+ dojo.raise("Could not load '" + moduleName + "'; last tried '" + relpath + "'");
+ }
+ }
+
+ // check that the symbol was defined
+ //Don't bother if we're doing xdomain (asynchronous) loading.
+ if(!omitModuleCheck && !this["isXDomain"]){
+ // pass in false so we can give better error
+ module = this.findModule(moduleName, false);
+ if(!module){
+ dojo.raise("symbol '" + moduleName + "' is not defined after loading '" + relpath + "'");
+ }
+ }
+
+ return module;
+}
+
+dojo.hostenv.startPackage = function(/*String*/packageName){
+// summary:
+// Creates a JavaScript package
+//
+// description:
+// startPackage("A.B") follows the path, and at each level creates a new empty
+// object or uses what already exists. It returns the result.
+//
+// packageName: the package to be created as a String in dot notation
+
+ //Make sure we have a string.
+ var fullPkgName = String(packageName);
+ var strippedPkgName = fullPkgName;
+
+ var syms = packageName.split(/\./);
+ if(syms[syms.length-1]=="*"){
+ syms.pop();
+ strippedPkgName = syms.join(".");
+ }
+ var evaledPkg = dojo.evalObjPath(strippedPkgName, true);
+ this.loaded_modules_[fullPkgName] = evaledPkg;
+ this.loaded_modules_[strippedPkgName] = evaledPkg;
+
+ return evaledPkg; // Object
+}
+
+dojo.hostenv.findModule = function(/*String*/moduleName, /*Boolean?*/mustExist){
+// summary:
+// Returns the Object representing the module, if it exists, otherwise null.
+//
+// moduleName A fully qualified module including package name, like 'A.B'.
+// mustExist Optional, default false. throw instead of returning null
+// if the module does not currently exist.
+
+ var lmn = String(moduleName);
+
+ if(this.loaded_modules_[lmn]){
+ return this.loaded_modules_[lmn]; // Object
+ }
+
+ if(mustExist){
+ dojo.raise("no loaded module named '" + moduleName + "'");
+ }
+ return null; // null
+}
+
+//Start of old bootstrap2:
+
+dojo.kwCompoundRequire = function(/*Object containing Arrays*/modMap){
+// description:
+// This method taks a "map" of arrays which one can use to optionally load dojo
+// modules. The map is indexed by the possible dojo.hostenv.name_ values, with
+// two additional values: "default" and "common". The items in the "default"
+// array will be loaded if none of the other items have been choosen based on
+// the hostenv.name_ item. The items in the "common" array will _always_ be
+// loaded, regardless of which list is chosen. Here's how it's normally
+// called:
+//
+// dojo.kwCompoundRequire({
+// browser: [
+// ["foo.bar.baz", true, true], // an example that passes multiple args to loadModule()
+// "foo.sample.*",
+// "foo.test,
+// ],
+// default: [ "foo.sample.*" ],
+// common: [ "really.important.module.*" ]
+// });
+
+ var common = modMap["common"]||[];
+ var result = modMap[dojo.hostenv.name_] ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]);
+
+ for(var x=0; x<result.length; x++){
+ var curr = result[x];
+ if(curr.constructor == Array){
+ dojo.hostenv.loadModule.apply(dojo.hostenv, curr);
+ }else{
+ dojo.hostenv.loadModule(curr);
+ }
+ }
+}
+
+dojo.require = function(/*String*/ resourceName){
+ // summary
+ // Ensure that the given resource (ie, javascript
+ // source file) has been loaded.
+ // description
+ // dojo.require() is similar to C's #include command or java's "import" command.
+ // You call dojo.require() to pull in the resources (ie, javascript source files)
+ // that define the functions you are using.
+ //
+ // Note that in the case of a build, many resources have already been included
+ // into dojo.js (ie, many of the javascript source files have been compressed and
+ // concatened into dojo.js), so many dojo.require() calls will simply return
+ // without downloading anything.
+ dojo.hostenv.loadModule.apply(dojo.hostenv, arguments);
+}
+
+dojo.requireIf = function(/*Boolean*/ condition, /*String*/ resourceName){
+ // summary
+ // If the condition is true then call dojo.require() for the specified resource
+ var arg0 = arguments[0];
+ if((arg0 === true)||(arg0=="common")||(arg0 && dojo.render[arg0].capable)){
+ var args = [];
+ for (var i = 1; i < arguments.length; i++) { args.push(arguments[i]); }
+ dojo.require.apply(dojo, args);
+ }
+}
+
+dojo.requireAfterIf = dojo.requireIf;
+
+dojo.provide = function(/*String*/ resourceName){
+ // summary
+ // Each javascript source file must have (exactly) one dojo.provide()
+ // call at the top of the file, corresponding to the file name.
+ // For example, dojo/src/foo.js must have dojo.provide("dojo.foo"); at the top of the file.
+ //
+ // description
+ // Each javascript source file is called a resource. When a resource
+ // is loaded by the browser, dojo.provide() registers that it has
+ // been loaded.
+ //
+ // For backwards compatibility reasons, in addition to registering the resource,
+ // dojo.provide() also ensures that the javascript object for the module exists. For
+ // example, dojo.provide("dojo.html.common"), in addition to registering that common.js
+ // is a resource for the dojo.html module, will ensure that the dojo.html javascript object
+ // exists, so that calls like dojo.html.foo = function(){ ... } don't fail.
+ //
+ // In the case of a build (or in the future, a rollup), where multiple javascript source
+ // files are combined into one bigger file (similar to a .lib or .jar file), that file
+ // will contain multiple dojo.provide() calls, to note that it includes
+ // multiple resources.
+ return dojo.hostenv.startPackage.apply(dojo.hostenv, arguments);
+}
+
+dojo.registerModulePath = function(/*String*/module, /*String*/prefix){
+ // summary: maps a module name to a path
+ // description: An unregistered module is given the default path of ../<module>,
+ // relative to Dojo root. For example, module acme is mapped to ../acme.
+ // If you want to use a different module name, use dojo.registerModulePath.
+ return dojo.hostenv.setModulePrefix(module, prefix);
+}
+
+dojo.setModulePrefix = function(/*String*/module, /*String*/prefix){
+ // summary: maps a module name to a path
+ dojo.deprecated('dojo.setModulePrefix("' + module + '", "' + prefix + '")', "replaced by dojo.registerModulePath", "0.5");
+ return dojo.registerModulePath(module, prefix);
+}
+
+dojo.exists = function(/*Object*/obj, /*String*/name){
+ // summary: determine if an object supports a given method
+ // description: useful for longer api chains where you have to test each object in the chain
+ var p = name.split(".");
+ for(var i = 0; i < p.length; i++){
+ if(!obj[p[i]]){ return false; } // Boolean
+ obj = obj[p[i]];
+ }
+ return true; // Boolean
+}
+
+// Localization routines
+
+dojo.hostenv.normalizeLocale = function(/*String?*/locale){
+// summary:
+// Returns canonical form of locale, as used by Dojo. All variants are case-insensitive and are separated by '-'
+// as specified in RFC 3066. If no locale is specified, the user agent's default is returned.
+
+ return locale ? locale.toLowerCase() : dojo.locale; // String
+};
+
+dojo.hostenv.searchLocalePath = function(/*String*/locale, /*Boolean*/down, /*Function*/searchFunc){
+// summary:
+// A helper method to assist in searching for locale-based resources. Will iterate through
+// the variants of a particular locale, either up or down, executing a callback function.
+// For example, "en-us" and true will try "en-us" followed by "en" and finally "ROOT".
+
+ locale = dojo.hostenv.normalizeLocale(locale);
+
+ var elements = locale.split('-');
+ var searchlist = [];
+ for(var i = elements.length; i > 0; i--){
+ searchlist.push(elements.slice(0, i).join('-'));
+ }
+ searchlist.push(false);
+ if(down){searchlist.reverse();}
+
+ for(var j = searchlist.length - 1; j >= 0; j--){
+ var loc = searchlist[j] || "ROOT";
+ var stop = searchFunc(loc);
+ if(stop){ break; }
+ }
+}
+
+//These two functions are placed outside of preloadLocalizations
+//So that the xd loading can use/override them.
+dojo.hostenv.localesGenerated /***BUILD:localesGenerated***/; // value will be inserted here at build time, if necessary
+
+dojo.hostenv.registerNlsPrefix = function(){
+// summary:
+// Register module "nls" to point where Dojo can find pre-built localization files
+ dojo.registerModulePath("nls","nls");
+}
+
+dojo.hostenv.preloadLocalizations = function(){
+// summary:
+// Load built, flattened resource bundles, if available for all locales used in the page.
+// Execute only once. Note that this is a no-op unless there is a build.
+
+ if(dojo.hostenv.localesGenerated){
+ dojo.hostenv.registerNlsPrefix();
+
+ function preload(locale){
+ locale = dojo.hostenv.normalizeLocale(locale);
+ dojo.hostenv.searchLocalePath(locale, true, function(loc){
+ for(var i=0; i<dojo.hostenv.localesGenerated.length;i++){
+ if(dojo.hostenv.localesGenerated[i] == loc){
+ dojo["require"]("nls.dojo_"+loc);
+ return true; // Boolean
+ }
+ }
+ return false; // Boolean
+ });
+ }
+ preload();
+ var extra = djConfig.extraLocale||[];
+ for(var i=0; i<extra.length; i++){
+ preload(extra[i]);
+ }
+ }
+ dojo.hostenv.preloadLocalizations = function(){};
+}
+
+dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){
+// summary:
+// Declares translated resources and loads them if necessary, in the same style as dojo.require.
+// Contents of the resource bundle are typically strings, but may be any name/value pair,
+// represented in JSON format. See also dojo.i18n.getLocalization.
+//
+// moduleName: name of the package containing the "nls" directory in which the bundle is found
+// bundleName: bundle name, i.e. the filename without the '.js' suffix
+// locale: the locale to load (optional) By default, the browser's user locale as defined by dojo.locale
+//
+// description:
+// Load translated resource bundles provided underneath the "nls" directory within a package.
+// Translated resources may be located in different packages throughout the source tree. For example,
+// a particular widget may define one or more resource bundles, structured in a program as follows,
+// where moduleName is mycode.mywidget and bundleNames available include bundleone and bundletwo:
+// ...
+// mycode/
+// mywidget/
+// nls/
+// bundleone.js (the fallback translation, English in this example)
+// bundletwo.js (also a fallback translation)
+// de/
+// bundleone.js
+// bundletwo.js
+// de-at/
+// bundleone.js
+// en/
+// (empty; use the fallback translation)
+// en-us/
+// bundleone.js
+// en-gb/
+// bundleone.js
+// es/
+// bundleone.js
+// bundletwo.js
+// ...etc
+// ...
+// Each directory is named for a locale as specified by RFC 3066, (http://www.ietf.org/rfc/rfc3066.txt),
+// normalized in lowercase. Note that the two bundles in the example do not define all the same variants.
+// For a given locale, bundles will be loaded for that locale and all more general locales above it, including
+// a fallback at the root directory. For example, a declaration for the "de-at" locale will first
+// load nls/de-at/bundleone.js, then nls/de/bundleone.js and finally nls/bundleone.js. The data will
+// be flattened into a single Object so that lookups will follow this cascading pattern. An optional build
+// step can preload the bundles to avoid data redundancy and the multiple network hits normally required to
+// load these resources.
+
+ dojo.hostenv.preloadLocalizations();
+ var bundlePackage = [moduleName, "nls", bundleName].join(".");
+//NOTE: When loading these resources, the packaging does not match what is on disk. This is an
+// implementation detail, as this is just a private data structure to hold the loaded resources.
+// e.g. tests/hello/nls/en-us/salutations.js is loaded as the object tests.hello.nls.salutations.en_us={...}
+// The structure on disk is intended to be most convenient for developers and translators, but in memory
+// it is more logical and efficient to store in a different order. Locales cannot use dashes, since the
+// resulting path will not evaluate as valid JS, so we translate them to underscores.
+
+ var bundle = dojo.hostenv.findModule(bundlePackage);
+ if(bundle){
+ if(djConfig.localizationComplete && bundle._built){return;}
+ var jsLoc = dojo.hostenv.normalizeLocale(locale).replace('-', '_');
+ var translationPackage = bundlePackage+"."+jsLoc;
+ if(dojo.hostenv.findModule(translationPackage)){return;}
+ }
+
+ bundle = dojo.hostenv.startPackage(bundlePackage);
+ var syms = dojo.hostenv.getModuleSymbols(moduleName);
+ var modpath = syms.concat("nls").join("/");
+ var parent;
+ dojo.hostenv.searchLocalePath(locale, false, function(loc){
+ var jsLoc = loc.replace('-', '_');
+ var translationPackage = bundlePackage + "." + jsLoc;
+ var loaded = false;
+ if(!dojo.hostenv.findModule(translationPackage)){
+ // Mark loaded whether it's found or not, so that further load attempts will not be made
+ dojo.hostenv.startPackage(translationPackage);
+ var module = [modpath];
+ if(loc != "ROOT"){module.push(loc);}
+ module.push(bundleName);
+ var filespec = module.join("/") + '.js';
+ loaded = dojo.hostenv.loadPath(filespec, null, function(hash){
+ // Use singleton with prototype to point to parent bundle, then mix-in result from loadPath
+ var clazz = function(){};
+ clazz.prototype = parent;
+ bundle[jsLoc] = new clazz();
+ for(var j in hash){ bundle[jsLoc][j] = hash[j]; }
+ });
+ }else{
+ loaded = true;
+ }
+ if(loaded && bundle[jsLoc]){
+ parent = bundle[jsLoc];
+ }else{
+ bundle[jsLoc] = parent;
+ }
+ });
+};
+
+(function(){
+ // If other locales are used, dojo.requireLocalization should load them as well, by default.
+ // Override dojo.requireLocalization to do load the default bundle, then iterate through the
+ // extraLocale list and load those translations as well, unless a particular locale was requested.
+
+ var extra = djConfig.extraLocale;
+ if(extra){
+ if(!extra instanceof Array){
+ extra = [extra];
+ }
+
+ var req = dojo.requireLocalization;
+ dojo.requireLocalization = function(m, b, locale){
+ req(m,b,locale);
+ if(locale){return;}
+ for(var i=0; i<extra.length; i++){
+ req(m,b,extra[i]);
+ }
+ };
+ }
+})();
Propchange: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/loader.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/loader_xd.js
URL: http://svn.apache.org/viewvc/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/loader_xd.js?view=auto&rev=474551
==============================================================================
--- struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/loader_xd.js (added)
+++ struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/loader_xd.js Mon Nov 13 14:54:45 2006
@@ -0,0 +1,437 @@
+/*
+ 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(){
+ //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(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("");
+}
+
+dojo.hostenv.loadPath = function(relpath, module /*optional*/, cb /*optional*/){
+ //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));
+ }catch(e){
+ dojo.debug(e);
+ return false;
+ }
+}
+
+//Overriding loadUri for now. Wanted to override getText(), but it is used by
+//the widget code in too many, synchronous ways right now. This means the xd stuff
+//is not suitable for widgets yet.
+dojo.hostenv.loadUri = function(uri, cb, currentIsXDomain, module){
+ if(this.loadedUris[uri]){
+ return 1;
+ }
+
+ //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; }
+
+ 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;
+}
+
+dojo.hostenv.packageLoaded = function(pkg){
+ 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;
+ }
+ }
+}
+
+//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){
+ //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};
+}
+
+//Walks the requires and evaluates package contents in
+//the right order.
+dojo.hostenv.xdWalkReqs = function(){
+ 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);
+ }
+ }
+}
+
+//Trace down any requires.
+dojo.hostenv.xdTraceReqs = function(reqs, reqChain){
+ 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);
+ }
+ }
+ }
+}
+
+//Do a depth first, breadth second search and eval or reqs.
+dojo.hostenv.xdEvalReqs = function(reqChain){
+ 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(){
+ clearInterval(this.xdTimer);
+ this.xdTimer = 0;
+}
+
+dojo.hostenv.watchInFlightXDomain = function(){
+ //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(target){
+ //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};
+ }
+ }
+ }
+}
+
+//Need to preload any flattened i18n bundles before we start
+//executing code, since we cannot do it synchronously, as the
+//i18n code normally expects.
+dojo.hostenv.xdHasCalledPreload = false;
+dojo.hostenv.xdRealCallLoaded = dojo.hostenv.callLoaded;
+dojo.hostenv.callLoaded = function(){
+ //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.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: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/loader_xd.js
------------------------------------------------------------------------------
svn:eol-style = native
Added: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/ConsoleLogger.js
URL: http://svn.apache.org/viewvc/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/ConsoleLogger.js?view=auto&rev=474551
==============================================================================
--- struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/ConsoleLogger.js (added)
+++ struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/ConsoleLogger.js Mon Nov 13 14:54:45 2006
@@ -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: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/ConsoleLogger.js
------------------------------------------------------------------------------
svn:eol-style = native
Modified: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/Logger.js
URL: http://svn.apache.org/viewvc/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/Logger.js?view=diff&rev=474551&r1=474550&r2=474551
==============================================================================
--- struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/Logger.js (original)
+++ struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/Logger.js Mon Nov 13 14:54:45 2006
@@ -1,5 +1,5 @@
/*
- Copyright (c) 2004-2005, The Dojo Foundation
+ Copyright (c) 2004-2006, The Dojo Foundation
All Rights Reserved.
Licensed under the Academic Free License version 2.1 or above OR the
@@ -8,10 +8,10 @@
http://dojotoolkit.org/community/licensing.shtml
*/
-/* This is the dojo logging facility, which is stolen from nWidgets, 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).
+/* 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
@@ -52,8 +52,7 @@
// Dependencies: none
dojo.provide("dojo.logging.Logger");
-dojo.provide("dojo.log");
-dojo.require("dojo.lang");
+dojo.require("dojo.lang.common");
/*
A simple data structure class that stores information for and about
@@ -64,8 +63,18 @@
dojo.logging.Record = function(lvl, msg){
this.level = lvl;
- this.message = msg;
+ this.message = "";
+ this.msgArgs = [];
this.time = new Date();
+
+ if(dojo.lang.isArray(msg)){
+ if(msg.length > 0 && dojo.lang.isString(msg[0])){
+ this.message=msg.shift();
+ }
+ this.msgArgs=msg;
+ }else{
+ this.message=msg;
+ }
// FIXME: what other information can we receive/discover here?
}
@@ -89,7 +98,7 @@
this.handlers = [];
}
-dojo.lang.extend(dojo.logging.Logger, {
+dojo.extend(dojo.logging.Logger,{
argsToArr: function(args){
// utility function, reproduced from __util__ here to remove dependency
var ret = [];
@@ -235,31 +244,21 @@
},
logType: function(type, args){
- var na = [dojo.logging.log.getLevel(type)];
- if(typeof args == "array"){
- na = na.concat(args);
- }else if((typeof args == "object")&&(args["length"])){
- na = na.concat(this.argsToArr(args));
- /* for(var x=0; x<args.length; x++){
- na.push(args[x]);
- } */
- }else{
- na = na.concat(this.argsToArr(arguments).slice(1));
- /* for(var x=1; x<arguments.length; x++){
- na.push(arguments[x]);
- } */
- }
- return this.log.apply(this, na);
+ return this.log.apply(this, [dojo.logging.log.getLevel(type),
+ args]);
+ },
+
+ warn:function(){
+ this.warning.apply(this,arguments);
+ },
+ err:function(){
+ this.error.apply(this,arguments);
+ },
+ crit:function(){
+ this.critical.apply(this,arguments);
}
});
-void(function(){
- var ptype = dojo.logging.Logger.prototype;
- ptype.warn = ptype.warning;
- ptype.err = ptype.error;
- ptype.crit = ptype.critical;
-})();
-
// the Handler class
dojo.logging.LogHandler = function(level){
this.cutOffLevel = (level) ? level : 0;
@@ -267,35 +266,26 @@
this.data = [];
this.filters = [];
}
-
-dojo.logging.LogHandler.prototype.setFormatter = function(fmtr){
- // FIXME: need to vet that it is indeed a formatter object
- dj_unimplemented("setFormatter");
-}
-
-dojo.logging.LogHandler.prototype.flush = function(){
- dj_unimplemented("flush");
-}
-
-dojo.logging.LogHandler.prototype.close = function(){
- dj_unimplemented("close");
-}
-
-dojo.logging.LogHandler.prototype.handleError = function(){
- dj_unimplemented("handleError");
-}
-
-dojo.logging.LogHandler.prototype.handle = function(record){
- // emits the passed record if it passes this object's filters
- if((this.filter(record))&&(record.level>=this.cutOffLevel)){
- this.emit(record);
+dojo.lang.extend(dojo.logging.LogHandler,{
+
+ setFormatter:function(formatter){
+ dojo.unimplemented("setFormatter");
+ },
+
+ flush:function(){},
+ close:function(){},
+ handleError:function(){},
+
+ handle:function(record){
+ if((this.filter(record))&&(record.level>=this.cutOffLevel)){
+ this.emit(record);
+ }
+ },
+
+ emit:function(record){
+ dojo.unimplemented("emit");
}
-}
-
-dojo.logging.LogHandler.prototype.emit = function(record){
- // do whatever is necessaray to actually log the record
- dj_unimplemented("emit");
-}
+});
// set aliases since we don't want to inherit from dojo.logging.Logger
void(function(){ // begin globals protection closure
@@ -368,41 +358,30 @@
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);
-
}
-// prototype inheritance
-dojo.logging.MemoryLogHandler.prototype = new dojo.logging.LogHandler();
-// FIXME
-// dj_inherits(dojo.logging.MemoryLogHandler,
-
-// over-ride base-class
-dojo.logging.MemoryLogHandler.prototype.emit = function(record){
- this.data.push(record);
- if(this.numRecords != -1){
- while(this.data.length>this.numRecords){
- this.data.shift();
+dojo.lang.inherits(dojo.logging.MemoryLogHandler, dojo.logging.LogHandler);
+dojo.lang.extend(dojo.logging.MemoryLogHandler,{
+
+ 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);
+ }
+
+ 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);
-// actual logging event handler
-dojo.logging.logQueueHandler.emit = function(record){
- // we should probably abstract this in the future
- var logStr = String(dojo.log.getLevelName(record.level)+": "+record.time.toLocaleTimeString())+": "+record.message;
- if(!dj_undef("debug", dj_global)){
- dojo.debug(logStr);
- }else if((typeof dj_global["print"] == "function")&&(!dojo.render.html.capable)){
- print(logStr);
- }
- this.data.push(record);
- if(this.numRecords != -1){
- while(this.data.length>this.numRecords){
- this.data.shift();
- }
- }
-}
dojo.logging.log.addHandler(dojo.logging.logQueueHandler);
dojo.log = dojo.logging.log;
Modified: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/__package__.js
URL: http://svn.apache.org/viewvc/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/__package__.js?view=diff&rev=474551&r1=474550&r2=474551
==============================================================================
--- struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/__package__.js (original)
+++ struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/logging/__package__.js Mon Nov 13 14:54:45 2006
@@ -1,5 +1,5 @@
/*
- Copyright (c) 2004-2005, The Dojo Foundation
+ Copyright (c) 2004-2006, The Dojo Foundation
All Rights Reserved.
Licensed under the Academic Free License version 2.1 or above OR the
@@ -8,8 +8,8 @@
http://dojotoolkit.org/community/licensing.shtml
*/
-dojo.hostenv.conditionalLoadModule({
- common: ["dojo.logging.Logger", false, false],
+dojo.kwCompoundRequire({
+ common: [["dojo.logging.Logger", false, false]],
rhino: ["dojo.logging.RhinoLogger"]
});
-dojo.hostenv.moduleLoaded("dojo.logging.*");
+dojo.provide("dojo.logging.*");
Modified: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math.js
URL: http://svn.apache.org/viewvc/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math.js?view=diff&rev=474551&r1=474550&r2=474551
==============================================================================
--- struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math.js (original)
+++ struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math.js Mon Nov 13 14:54:45 2006
@@ -1,5 +1,5 @@
/*
- Copyright (c) 2004-2005, The Dojo Foundation
+ Copyright (c) 2004-2006, The Dojo Foundation
All Rights Reserved.
Licensed under the Academic Free License version 2.1 or above OR the
@@ -10,39 +10,49 @@
dojo.provide("dojo.math");
-dojo.math.degToRad = function (x) { return (x*Math.PI) / 180; }
-dojo.math.radToDeg = function (x) { return (x*180) / Math.PI; }
+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 (n) {
+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;
+ return retVal; // integer
}
-//The number of ways of obtaining an ordered subset of k elements from a set of n elements
-dojo.math.permutations = function (n,k) {
+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));
+ return (dojo.math.factorial(n) / dojo.math.factorial(n-k)); // float
}
-//The number of ways of picking n unordered outcomes from r possibilities
-dojo.math.combinations = function (n,r) {
+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)));
+ return (dojo.math.factorial(n) / (dojo.math.factorial(n-r) * dojo.math.factorial(r))); // float
}
-dojo.math.bernstein = function (t,n,i) {
- return (dojo.math.combinations(n,i) * Math.pow(t,i) * Math.pow(1-t,n-i));
+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
}
-/**
- * Returns random numbers with a Gaussian distribution, with the mean set at
- * 0 and the variance set at 1.
- *
- * @return A random number from a Gaussian distribution
- */
-dojo.math.gaussianRandom = function () {
+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;
@@ -50,66 +60,49 @@
k = i * i + j * j;
} while (k >= 1);
k = Math.sqrt((-2 * Math.log(k)) / k);
- return i * k;
+ return i * k; // float
}
-/**
- * Calculates the mean of an Array of numbers.
- *
- * @return The mean of the numbers in the Array
- */
-dojo.math.mean = function () {
+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;
+ return mean / array.length; // float
}
-/**
- * Extends Math.round by adding a second argument specifying the number of
- * decimal places to round to.
- *
- * @param number The number to round
- * @param places The number of decimal places to round to
- * @return The rounded number
- */
-// TODO: add support for significant figures
-dojo.math.round = function (number, places) {
+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;
+ return Math.round(number * shift) / shift; // float
}
-/**
- * Calculates the standard deviation of an Array of numbers
- *
- * @return The standard deviation of the numbers
- */
-dojo.math.sd = function () {
+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));
+ return Math.sqrt(dojo.math.variance(array)); // float
}
-/**
- * Calculates the variance of an Array of numbers
- *
- * @return The variance of the numbers
- */
-dojo.math.variance = function () {
+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);
+ return (squares / array.length) - Math.pow(mean / array.length, 2); // float
}
-/**
- * Like range() in python
-**/
-dojo.math.range = function(a, b, step) {
+dojo.math.range = function(/* integer */a, /* integer */b, /* integer */step) {
+ // summary
+ // implementation of Python's range()
if(arguments.length < 2) {
b = a;
a = 0;
@@ -130,5 +123,5 @@
} else {
throw new Error("dojo.math.range: step must be non-zero");
}
- return range;
+ return range; // array
}
Modified: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/__package__.js
URL: http://svn.apache.org/viewvc/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/__package__.js?view=diff&rev=474551&r1=474550&r2=474551
==============================================================================
--- struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/__package__.js (original)
+++ struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/__package__.js Mon Nov 13 14:54:45 2006
@@ -1,5 +1,5 @@
/*
- Copyright (c) 2004-2005, The Dojo Foundation
+ Copyright (c) 2004-2006, The Dojo Foundation
All Rights Reserved.
Licensed under the Academic Free License version 2.1 or above OR the
@@ -8,11 +8,11 @@
http://dojotoolkit.org/community/licensing.shtml
*/
-dojo.hostenv.conditionalLoadModule({
+dojo.kwCompoundRequire({
common: [
["dojo.math", false, false],
["dojo.math.curves", false, false],
["dojo.math.points", false, false]
]
});
-dojo.hostenv.moduleLoaded("dojo.math.*");
+dojo.provide("dojo.math.*");
Modified: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/curves.js
URL: http://svn.apache.org/viewvc/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/curves.js?view=diff&rev=474551&r1=474550&r2=474551
==============================================================================
--- struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/curves.js (original)
+++ struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/curves.js Mon Nov 13 14:54:45 2006
@@ -1,5 +1,5 @@
/*
- Copyright (c) 2004-2005, The Dojo Foundation
+ Copyright (c) 2004-2006, The Dojo Foundation
All Rights Reserved.
Licensed under the Academic Free License version 2.1 or above OR the
@@ -9,7 +9,6 @@
*/
dojo.provide("dojo.math.curves");
-
dojo.require("dojo.math");
/* Curves from Dan's 13th lib stuff.
@@ -18,8 +17,9 @@
*/
dojo.math.curves = {
- //Creates a straight line object
- Line: function(start, end) {
+ Line: function(/* array */start, /* array */end) {
+ // summary
+ // Creates a straight line object
this.start = start;
this.end = end;
this.dimensions = start.length;
@@ -33,21 +33,25 @@
}
//simple function to find point on an n-dimensional, straight line
- this.getValue = function(n) {
+ 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;
+ return retVal; // array
}
-
- return this;
+ return this; // dojo.math.curves.Line
},
-
- //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.
- Bezier: function(pnts) {
- this.getValue = function(step) {
+ 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);
@@ -63,16 +67,18 @@
}
retVal[j] = C/D;
}
- return retVal;
+ return retVal; // array
}
this.p = pnts;
- return this;
+ return this; // dojo.math.curves.Bezier
},
-
- //Catmull-Rom Spline - allows you to interpolate a smooth curve through a set of points in n-dimensional space
- CatmullRom : function(pnts,c) {
- this.getValue = function(step) {
+ 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;
@@ -95,21 +101,21 @@
retVal[k] = x1*u3 + x2*u2 + x3*u + x4;
}
- return retVal;
-
+ return retVal; // array
}
-
if(!c) this.c = 0.7;
else this.c = c;
this.p = pnts;
- return this;
+ 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(start, end, ccw) {
+ 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));
@@ -122,43 +128,51 @@
dojo.math.curves.CenteredArc.call(this, center, rad, theta, theta+(ccw?-180:180));
},
- // 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
- CenteredArc : function(center, radius, start, end) {
+ 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(n) {
+ 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;
+
+ return retVal; // array
}
- return this;
+ return this; // dojo.math.curves.CenteredArc
},
- // Special case of Arc (start = 0, end = 360)
- Circle : function(center, radius) {
+ 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;
+ 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(curve, weight) {
+ 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);
@@ -166,7 +180,9 @@
computeRanges();
}
- this.remove = function(curve) {
+ 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);
@@ -178,12 +194,16 @@
}
this.removeAll = function() {
+ // summary
+ // Remove all curve segments
curves = [];
weights = [];
totalWeight = 0;
}
- this.getValue = function(n) {
+ 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];
@@ -201,10 +221,10 @@
value = curves[curves.length-1].getValue(1);
}
- for(j = 0; j < i; j++) {
+ for(var j = 0; j < i; j++) {
value = dojo.math.points.translate(value, curves[j].getValue(1));
}
- return value;
+ return value; // array
}
function computeRanges() {
@@ -217,6 +237,6 @@
}
}
- return this;
+ return this; // dojo.math.curves.Path
}
};
Modified: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/matrix.js
URL: http://svn.apache.org/viewvc/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/matrix.js?view=diff&rev=474551&r1=474550&r2=474551
==============================================================================
--- struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/matrix.js (original)
+++ struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/matrix.js Mon Nov 13 14:54:45 2006
@@ -1,5 +1,5 @@
/*
- Copyright (c) 2004-2005, The Dojo Foundation
+ Copyright (c) 2004-2006, The Dojo Foundation
All Rights Reserved.
Licensed under the Academic Free License version 2.1 or above OR the
@@ -10,7 +10,6 @@
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)
@@ -20,18 +19,31 @@
// 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){
-
- a = dojo.math.matrix.copy(a);
- b = dojo.math.matrix.copy(b);
-
- var ax = a[0].length;
var ay = a.length;
- var bx = b[0].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);
@@ -39,57 +51,97 @@
}
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;
}
-dojo.math.matrix.inverse = function(a){
+// 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;
+}
- a = dojo.math.matrix.copy(a);
+
+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){
+ 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 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){
-
- a = dojo.math.matrix.copy(a);
-
if (a.length != a[0].length){
dojo.debug("Can't calculate the determiant of a non-squre matrix!");
return 0;
@@ -97,91 +149,127 @@
var tms = a.length;
var det = 1;
-
var b = dojo.math.matrix.upperTriangle(a);
for (var i=0; i < tms; i++){
- det *= b[i][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.copy(m);
-
+ m = dojo.math.matrix.copy(m); // Copy m, because m is changed!
var f1 = 0;
var temp = 0;
var tms = m.length;
var v = 1;
+ //Erel: why use a global variable and not a local variable?
dojo.math.matrix.iDF = 1;
for (var col = 0; col < tms - 1; col++) {
- for (var row = col + 1; row < tms; row++) {
- v = 1;
-
- var stop_loop = 0;
-
- // check if 0 in diagonal
- while ((m[col][col] == 0) && !stop_loop){
-
- // if so switch until not
- if (col + v >= tms){
-
- // check if switched all rows
- dojo.math.matrix.iDF = 0;
- stop_loop = 1;
- }else{
- for (var c = 0; c < tms; c++) {
- temp = m[col][c];
- m[col][c] = m[col + v][c]; // switch rows
- m[col + v][c] = temp;
- }
- v++; // count row switchs
- dojo.math.matrix.iDF *= -1; // each switch changes determinant factor
+ if (typeof m[col][col] != 'number'){
+ dojo.debug("non-numeric entry found in a numeric matrix: m["+col+"]["+col+"]="+m[col][col]);
+ }
+ v = 1;
+ var stop_loop = 0;
+
+ // check if there is a 0 in diagonal
+ while ((m[col][col] == 0) && !stop_loop) {
+ // if so, switch rows until there is no 0 in diagonal:
+ if (col + v >= tms){
+ // check if switched all rows
+ dojo.math.matrix.iDF = 0;
+ stop_loop = 1;
+ }else{
+ for (var r = 0; r < tms; r++) {
+ temp = m[col][r];
+ m[col][r] = m[col + v][r]; // switch rows
+ m[col + v][r] = temp;
}
+ v++; // count row switchs
+ dojo.math.matrix.iDF *= -1; // each switch changes determinant factor
+ }
+ }
+
+ // loop over lower-right triangle (where row>col):
+ // for each row, make m[row][col] = 0 by linear operations that don't change the determinant:
+ for (var row = col + 1; row < tms; row++) {
+ if (typeof m[row][col] != 'number'){
+ dojo.debug("non-numeric entry found in a numeric matrix: m["+row+"]["+col+"]="+m[row][col]);
+ }
+ if (typeof m[col][row] != 'number'){
+ dojo.debug("non-numeric entry found in a numeric matrix: m["+col+"]["+row+"]="+m[col][row]);
}
-
if (m[col][col] != 0) {
- f1 = (-1) * m[row][col] / m[col][col];
+ var f1 = (-1) * m[row][col] / m[col][col];
+ // this should make m[row][col] zero:
+ // m[row] += f1 * m[col];
for (var i = col; i < tms; i++) {
m[row][i] = f1 * m[col][i] + m[row][i];
}
}
}
}
-
return m;
}
-dojo.math.matrix.create = function(a, b){
+// Erel: added parameter "value" - a custom default value to fill the matrix with.
+dojo.math.matrix.create = function(a, b, value){
+ if(!value){
+ value = 0;
+ }
var m = [];
for(var i=0; i<b; i++){
m[i] = [];
for(var j=0; j<a; j++){
- m[i][j] = 0;
+ m[i][j] = value;
}
}
return m;
}
-dojo.math.matrix.adjoint = function(a){
+// Erel implement Matlab[TM] functions "ones" and "zeros"
+dojo.math.matrix.ones = function(a,b) {
+ return dojo.math.matrix.create(a,b,1);
+}
+dojo.math.matrix.zeros = function(a,b) {
+ return dojo.math.matrix.create(a,b,0);
+}
- a = dojo.math.matrix.copy(a);
+// Erel: added function that returns identity matrix.
+// size = number of rows and cols in the matrix.
+// scale = an optional value to multiply the matrix by (default is 1).
+dojo.math.matrix.identity = function(size, scale){
+ if (!scale){
+ scale = 1;
+ }
+ var m = [];
+ for(var i=0; i<size; i++){
+ m[i] = [];
+ for(var j=0; j<size; j++){
+ m[i][j] = (i==j? scale: 0);
+ }
+ }
+ return m;
+}
+dojo.math.matrix.adjoint = function(a){
var tms = a.length;
- if (a.length != a[0].length){
- dojo.debug("Can't find the adjoint of a non-square matrix");
+ // Erel: added "<=" to catch zero-size matrix
+ if (tms <= 1){
+ dojo.debug("Can't find the adjoint of a matrix with a dimension less than 2");
return [[0]];
}
- if (tms == 1){
- dojo.debug("Can't find the adjoint of a 1x1 matrix");
+ if (a.length != a[0].length){
+ dojo.debug("Can't find the adjoint of a non-square matrix");
return [[0]];
}
@@ -192,57 +280,51 @@
var ia = 0;
var ja = 0;
var det = 0;
+ var ap = dojo.math.matrix.create(tms-1, tms-1);
for (var i = 0; i < tms; i++){
for (var j = 0; j < tms; j++){
-
ia = 0;
- ja = 0;
-
- var ap = dojo.math.matrix.create(tms-1, tms-1);
-
- for (ii = 0; ii < tms; ii++) {
+ for (ii = 0; ii < tms; ii++) { // create a temporary matrix for determinant calc
+ if (ii==i){
+ continue; // skip current row
+ }
+ ja = 0;
for (jj = 0; jj < tms; jj++) {
-
- if ((ii != i) && (jj != j)) {
- ap[ia][ja] = a[ii][jj];
- ja++;
+ if (jj==j){
+ continue; // skip current col
}
-
- }
-
- if ((ii != i) && (jj != j)) {
- ia++;
+ ap[ia][ja] = a[ii][jj];
+ ja++;
}
- ja = 0;
+ ia++;
}
-
+
det = dojo.math.matrix.determinant(ap);
m[i][j] = Math.pow(-1 , (i + j)) * det;
}
}
-
m = dojo.math.matrix.transpose(m);
-
return m;
}
dojo.math.matrix.transpose = function(a){
-
- a = dojo.math.matrix.copy(a);
-
var m = dojo.math.matrix.create(a.length, a[0].length);
-
- for (var i = 0; i < a.length; i++)
- for (var j = 0; j < a[i].length; j++)
+ for (var i = 0; i < a.length; i++){
+ for (var j = 0; j < a[i].length; j++){
m[j][i] = a[i][j];
+ }
+ }
return m;
}
-dojo.math.matrix.format = function(a){
+// Erel: added decimal_points argument
+dojo.math.matrix.format = function(a, decimal_points){
+ if (arguments.length<=1){
+ decimal_points = 5;
+ }
- function format_int(x){
- var dp = 5;
+ function format_int(x, dp){
var fac = Math.pow(10 , dp);
var a = Math.round(x*fac)/fac;
var b = a.toString();
@@ -257,41 +339,32 @@
}
var ya = a.length;
- var xa = a[0].length;
-
+ var xa = ya>0? a[0].length: 0;
var buffer = '';
-
for (var y=0; y<ya; y++){
buffer += '| ';
for (var x=0; x<xa; x++){
- buffer += format_int(a[y][x]) + ' ';
+ buffer += format_int(a[y][x], decimal_points) + ' ';
}
buffer += '|\n';
}
-
return buffer;
}
dojo.math.matrix.copy = function(a){
-
var ya = a.length;
var xa = a[0].length;
-
var m = dojo.math.matrix.create(xa, ya);
-
for (var y=0; y<ya; y++){
for (var x=0; x<xa; x++){
m[y][x] = a[y][x];
}
}
-
return m;
}
dojo.math.matrix.scale = function(k, a){
-
- a = dojo.math.matrix.copy(a);
-
+ a = dojo.math.matrix.copy(a); // Copy a because a is changed!
var ya = a.length;
var xa = a[0].length;
@@ -300,6 +373,5 @@
a[y][x] *= k;
}
}
-
return a;
}
Modified: struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/points.js
URL: http://svn.apache.org/viewvc/struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/points.js?view=diff&rev=474551&r1=474550&r2=474551
==============================================================================
--- struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/points.js (original)
+++ struts/struts2/trunk/core/src/main/resources/org/apache/struts2/static/dojo/src/math/points.js Mon Nov 13 14:54:45 2006
@@ -1,5 +1,5 @@
/*
- Copyright (c) 2004-2005, The Dojo Foundation
+ Copyright (c) 2004-2006, The Dojo Foundation
All Rights Reserved.
Licensed under the Academic Free License version 2.1 or above OR the
@@ -11,9 +11,10 @@
dojo.provide("dojo.math.points");
dojo.require("dojo.math");
-// TODO: add a Point class?
dojo.math.points = {
- translate: function(a, b) {
+ translate: function(/* array */a, /* array */b) {
+ // summary
+ // translate a by b, and return the result.
if( a.length != b.length ) {
dojo.raise("dojo.math.translate: points not same size (a:[" + a + "], b:[" + b + "])");
}
@@ -21,10 +22,12 @@
for(var i = 0; i < a.length; i++) {
c[i] = a[i] + b[i];
}
- return c;
+ return c; // array
},
- midpoint: function(a, b) {
+ midpoint: function(/* array */a, /* array */b) {
+ // summary
+ // Find the point midway between a and b
if( a.length != b.length ) {
dojo.raise("dojo.math.midpoint: points not same size (a:[" + a + "], b:[" + b + "])");
}
@@ -32,16 +35,20 @@
for(var i = 0; i < a.length; i++) {
c[i] = (a[i] + b[i]) / 2;
}
- return c;
+ return c; // array
},
- invert: function(a) {
+ invert: function(/* array */a) {
+ // summary
+ // invert the values in a and return it.
var b = new Array(a.length);
for(var i = 0; i < a.length; i++) { b[i] = -a[i]; }
- return b;
+ return b; // array
},
- distance: function(a, b) {
- return Math.sqrt(Math.pow(b[0]-a[0], 2) + Math.pow(b[1]-a[1], 2));
+ distance: function(/* array */a, /* array */b) {
+ // summary
+ // Calculate the distance between point a and point b
+ return Math.sqrt(Math.pow(b[0]-a[0], 2) + Math.pow(b[1]-a[1], 2)); // float
}
};