| /* |
| 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 |
| */ |
| |
| if(typeof dojo == "undefined"){ |
| |
| // TODOC: HOW TO DOC THE BELOW? |
| // @global: djConfig |
| // summary: |
| // Application code can set the global 'djConfig' prior to loading |
| // the library to override certain global settings for how dojo works. |
| // description: The variables that can be set are as follows: |
| // - isDebug: false |
| // - allowQueryConfig: false |
| // - baseScriptUri: "" |
| // - baseRelativePath: "" |
| // - libraryScriptUri: "" |
| // - iePreventClobber: false |
| // - ieClobberMinimal: true |
| // - locale: undefined |
| // - extraLocale: undefined |
| // - preventBackButtonFix: true |
| // - searchIds: [] |
| // - parseWidgets: true |
| // TODOC: HOW TO DOC THESE VARIABLES? |
| // TODOC: IS THIS A COMPLETE LIST? |
| // note: |
| // 'djConfig' does not exist under 'dojo.*' so that it can be set before the |
| // 'dojo' variable exists. |
| // note: |
| // Setting any of these variables *after* the library has loaded does nothing at all. |
| // TODOC: is this still true? Release notes for 0.3 indicated they could be set after load. |
| // |
| |
| |
| //TODOC: HOW TO DOC THIS? |
| // @global: dj_global |
| // summary: |
| // an alias for the top-level global object in the host environment |
| // (e.g., the window object in a browser). |
| // description: |
| // Refer to 'dj_global' rather than referring to window to ensure your |
| // code runs correctly in contexts other than web browsers (eg: Rhino on a server). |
| var dj_global = this; |
| |
| //TODOC: HOW TO DOC THIS? |
| // @global: dj_currentContext |
| // summary: |
| // Private global context object. Where 'dj_global' always refers to the boot-time |
| // global context, 'dj_currentContext' can be modified for temporary context shifting. |
| // dojo.global() returns dj_currentContext. |
| // description: |
| // Refer to dojo.global() rather than referring to dj_global to ensure your |
| // code runs correctly in managed contexts. |
| var dj_currentContext = this; |
| |
| |
| // **************************************************************** |
| // global public utils |
| // TODOC: DO WE WANT TO NOTE THAT THESE ARE GLOBAL PUBLIC UTILS? |
| // **************************************************************** |
| |
| function dj_undef(/*String*/ name, /*Object?*/ object){ |
| //summary: Returns true if 'name' is defined on 'object' (or globally if 'object' is null). |
| //description: Note that 'defined' and 'exists' are not the same concept. |
| return (typeof (object || dj_currentContext)[name] == "undefined"); // Boolean |
| } |
| |
| // make sure djConfig is defined |
| if(dj_undef("djConfig", this)){ |
| var djConfig = {}; |
| } |
| |
| //TODOC: HOW TO DOC THIS? |
| // dojo is the root variable of (almost all) our public symbols -- make sure it is defined. |
| if(dj_undef("dojo", this)){ |
| var dojo = {}; |
| } |
| |
| dojo.global = function(){ |
| // summary: |
| // return the current global context object |
| // (e.g., the window object in a browser). |
| // description: |
| // Refer to 'dojo.global()' rather than referring to window to ensure your |
| // code runs correctly in contexts other than web browsers (eg: Rhino on a server). |
| return dj_currentContext; |
| } |
| |
| // Override locale setting, if specified |
| dojo.locale = djConfig.locale; |
| |
| //TODOC: HOW TO DOC THIS? |
| dojo.version = { |
| // summary: version number of this instance of dojo. |
| major: 0, minor: 4, patch: 3, flag: "", |
| revision: Number("$Rev$".match(/[0-9]+/)[0]), |
| toString: function(){ |
| with(dojo.version){ |
| return major + "." + minor + "." + patch + flag + " (" + revision + ")"; // String |
| } |
| } |
| } |
| |
| dojo.evalProp = function(/*String*/ name, /*Object*/ object, /*Boolean?*/ create){ |
| // summary: Returns 'object[name]'. If not defined and 'create' is true, will return a new Object. |
| // description: |
| // Returns null if 'object[name]' is not defined and 'create' is not true. |
| // Note: 'defined' and 'exists' are not the same concept. |
| if((!object)||(!name)) return undefined; // undefined |
| if(!dj_undef(name, object)) return object[name]; // mixed |
| return (create ? (object[name]={}) : undefined); // mixed |
| } |
| |
| dojo.parseObjPath = function(/*String*/ path, /*Object?*/ context, /*Boolean?*/ create){ |
| // summary: Parse string path to an object, and return corresponding object reference and property name. |
| // description: |
| // Returns an object with two properties, 'obj' and 'prop'. |
| // 'obj[prop]' is the reference indicated by 'path'. |
| // path: Path to an object, in the form "A.B.C". |
| // context: Object to use as root of path. Defaults to 'dojo.global()'. |
| // create: If true, Objects will be created at any point along the 'path' that is undefined. |
| var object = (context || dojo.global()); |
| var names = path.split('.'); |
| var prop = names.pop(); |
| for (var i=0,l=names.length;i<l && object;i++){ |
| object = dojo.evalProp(names[i], object, create); |
| } |
| return {obj: object, prop: prop}; // Object: {obj: Object, prop: String} |
| } |
| |
| dojo.evalObjPath = function(/*String*/ path, /*Boolean?*/ create){ |
| // summary: Return the value of object at 'path' in the global scope, without using 'eval()'. |
| // path: Path to an object, in the form "A.B.C". |
| // create: If true, Objects will be created at any point along the 'path' that is undefined. |
| if(typeof path != "string"){ |
| return dojo.global(); |
| } |
| // fast path for no periods |
| if(path.indexOf('.') == -1){ |
| return dojo.evalProp(path, dojo.global(), create); // mixed |
| } |
| |
| //MOW: old 'with' syntax was confusing and would throw an error if parseObjPath returned null. |
| var ref = dojo.parseObjPath(path, dojo.global(), create); |
| if(ref){ |
| return dojo.evalProp(ref.prop, ref.obj, create); // mixed |
| } |
| return null; |
| } |
| |
| dojo.errorToString = function(/*Error*/ exception){ |
| // summary: Return an exception's 'message', 'description' or text. |
| |
| // TODO: overriding Error.prototype.toString won't accomplish this? |
| // ... since natively generated Error objects do not always reflect such things? |
| if(!dj_undef("message", exception)){ |
| return exception.message; // String |
| }else if(!dj_undef("description", exception)){ |
| return exception.description; // String |
| }else{ |
| return exception; // Error |
| } |
| } |
| |
| dojo.raise = function(/*String*/ message, /*Error?*/ exception){ |
| // summary: Common point for raising exceptions in Dojo to enable logging. |
| // Throws an error message with text of 'exception' if provided, or |
| // rethrows exception object. |
| |
| if(exception){ |
| message = message + ": "+dojo.errorToString(exception); |
| }else{ |
| message = dojo.errorToString(message); |
| } |
| |
| // print the message to the user if hostenv.println is defined |
| try { if(djConfig.isDebug){ dojo.hostenv.println("FATAL exception raised: "+message); } } catch (e) {} |
| |
| throw exception || Error(message); |
| } |
| |
| //Stub functions so things don't break. |
| //TODOC: HOW TO DOC THESE? |
| dojo.debug = function(){}; |
| dojo.debugShallow = function(obj){}; |
| dojo.profile = { start: function(){}, end: function(){}, stop: function(){}, dump: function(){} }; |
| |
| function dj_eval(/*String*/ scriptFragment){ |
| // summary: Perform an evaluation in the global scope. Use this rather than calling 'eval()' directly. |
| // description: Placed in a separate function to minimize size of trapped evaluation context. |
| // note: |
| // - JSC eval() takes an optional second argument which can be 'unsafe'. |
| // - Mozilla/SpiderMonkey eval() takes an optional second argument which is the |
| // scope object for new symbols. |
| return dj_global.eval ? dj_global.eval(scriptFragment) : eval(scriptFragment); // mixed |
| } |
| |
| dojo.unimplemented = function(/*String*/ funcname, /*String?*/ extra){ |
| // summary: Throw an exception because some function is not implemented. |
| // extra: Text to append to the exception message. |
| var message = "'" + funcname + "' not implemented"; |
| if (extra != null) { message += " " + extra; } |
| dojo.raise(message); |
| } |
| |
| dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){ |
| // summary: Log a debug message to indicate that a behavior has been deprecated. |
| // extra: Text to append to the message. |
| // removal: Text to indicate when in the future the behavior will be removed. |
| var message = "DEPRECATED: " + behaviour; |
| if(extra){ message += " " + extra; } |
| if(removal){ message += " -- will be removed in version: " + removal; } |
| dojo.debug(message); |
| } |
| |
| dojo.render = (function(){ |
| //TODOC: HOW TO DOC THIS? |
| // summary: Details rendering support, OS and browser of the current environment. |
| // TODOC: is this something many folks will interact with? If so, we should doc the structure created... |
| function vscaffold(prefs, names){ |
| var tmp = { |
| capable: false, |
| support: { |
| builtin: false, |
| plugin: false |
| }, |
| prefixes: prefs |
| }; |
| for(var i=0; i<names.length; i++){ |
| tmp[names[i]] = false; |
| } |
| return tmp; |
| } |
| |
| return { |
| name: "", |
| ver: dojo.version, |
| os: { win: false, linux: false, osx: false }, |
| html: vscaffold(["html"], ["ie", "opera", "khtml", "safari", "moz"]), |
| svg: vscaffold(["svg"], ["corel", "adobe", "batik"]), |
| vml: vscaffold(["vml"], ["ie"]), |
| swf: vscaffold(["Swf", "Flash", "Mm"], ["mm"]), |
| swt: vscaffold(["Swt"], ["ibm"]) |
| }; |
| })(); |
| |
| // **************************************************************** |
| // dojo.hostenv methods that must be defined in hostenv_*.js |
| // **************************************************************** |
| |
| /** |
| * The interface definining the interaction with the EcmaScript host environment. |
| */ |
| |
| /* |
| * None of these methods should ever be called directly by library users. |
| * Instead public methods such as loadModule should be called instead. |
| */ |
| dojo.hostenv = (function(){ |
| // TODOC: HOW TO DOC THIS? |
| // summary: Provides encapsulation of behavior that changes across different 'host environments' |
| // (different browsers, server via Rhino, etc). |
| // description: None of these methods should ever be called directly by library users. |
| // Use public methods such as 'loadModule' instead. |
| |
| // default configuration options |
| var config = { |
| isDebug: false, |
| allowQueryConfig: false, |
| baseScriptUri: "", |
| baseRelativePath: "", |
| libraryScriptUri: "", |
| iePreventClobber: false, |
| ieClobberMinimal: true, |
| preventBackButtonFix: true, |
| delayMozLoadingFix: false, |
| searchIds: [], |
| parseWidgets: true |
| }; |
| |
| if (typeof djConfig == "undefined") { djConfig = config; } |
| else { |
| for (var option in config) { |
| if (typeof djConfig[option] == "undefined") { |
| djConfig[option] = config[option]; |
| } |
| } |
| } |
| |
| return { |
| name_: '(unset)', |
| version_: '(unset)', |
| |
| |
| getName: function(){ |
| // sumary: Return the name of the host environment. |
| return this.name_; // String |
| }, |
| |
| |
| getVersion: function(){ |
| // summary: Return the version of the hostenv. |
| return this.version_; // String |
| }, |
| |
| getText: function(/*String*/ uri){ |
| // summary: Read the plain/text contents at the specified 'uri'. |
| // description: |
| // If 'getText()' is not implemented, then it is necessary to override |
| // 'loadUri()' with an implementation that doesn't rely on it. |
| |
| dojo.unimplemented('getText', "uri=" + uri); |
| } |
| }; |
| })(); |
| |
| |
| dojo.hostenv.getBaseScriptUri = function(){ |
| // summary: Return the base script uri that other scripts are found relative to. |
| // TODOC: HUH? This comment means nothing to me. What other scripts? Is this the path to other dojo libraries? |
| // MAYBE: Return the base uri to scripts in the dojo library. ??? |
| // return: Empty string or a path ending in '/'. |
| if(djConfig.baseScriptUri.length){ |
| return djConfig.baseScriptUri; |
| } |
| |
| // MOW: Why not: |
| // uri = djConfig.libraryScriptUri || djConfig.baseRelativePath |
| // ??? Why 'new String(...)' |
| var uri = new String(djConfig.libraryScriptUri||djConfig.baseRelativePath); |
| if (!uri) { dojo.raise("Nothing returned by getLibraryScriptUri(): " + uri); } |
| |
| // MOW: uri seems to not be actually used. Seems to be hard-coding to djConfig.baseRelativePath... ??? |
| var lastslash = uri.lastIndexOf('/'); // MOW ??? |
| djConfig.baseScriptUri = djConfig.baseRelativePath; |
| return djConfig.baseScriptUri; // String |
| } |
| |
| /* |
| * 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(){ |
| //The "object" check is for IE, and the other opera check fixes an issue |
| //in Opera where it could not find the body element in some widget test cases. |
| //For 0.9, maybe route all browsers through the setTimeout (need protection |
| //still for non-browser environments though). This might also help the issue with |
| //FF 2.0 and freezing issues where we try to do sync xhr while background css images |
| //are being loaded (trac #2572)? Consider for 0.9. |
| if(typeof setTimeout == "object" || (djConfig["useXDomain"] && dojo.render.html.opera)){ |
| 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) for top-level modules |
| 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); |
| } |
| |
| if(djConfig["modulePaths"]){ |
| for(var param in djConfig["modulePaths"]){ |
| dojo.registerModulePath(param, djConfig["modulePaths"][param]); |
| } |
| } |
| |
| 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. |
| |
| var result = locale ? locale.toLowerCase() : dojo.locale; |
| if(result == "root"){ |
| result = "ROOT"; |
| } |
| return result;// 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, /*String?*/availableFlatLocales){ |
| // 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 |
| // availableFlatLocales: A comma-separated list of the available, flattened locales for this bundle. |
| // This argument should only be set by the build process. |
| // |
| // 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 targetLocale = dojo.hostenv.normalizeLocale(locale); |
| 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. |
| |
| //Find the best-match locale to load if we have available flat locales. |
| var bestLocale = ""; |
| if(availableFlatLocales){ |
| var flatLocales = availableFlatLocales.split(","); |
| for(var i = 0; i < flatLocales.length; i++){ |
| //Locale must match from start of string. |
| if(targetLocale.indexOf(flatLocales[i]) == 0){ |
| if(flatLocales[i].length > bestLocale.length){ |
| bestLocale = flatLocales[i]; |
| } |
| } |
| } |
| if(!bestLocale){ |
| bestLocale = "ROOT"; |
| } |
| } |
| |
| //See if the desired locale is already loaded. |
| var tempLocale = availableFlatLocales ? bestLocale : targetLocale; |
| var bundle = dojo.hostenv.findModule(bundlePackage); |
| var localizedBundle = null; |
| if(bundle){ |
| if(djConfig.localizationComplete && bundle._built){return;} |
| var jsLoc = tempLocale.replace('-', '_'); |
| var translationPackage = bundlePackage+"."+jsLoc; |
| localizedBundle = dojo.hostenv.findModule(translationPackage); |
| } |
| |
| if(!localizedBundle){ |
| bundle = dojo.hostenv.startPackage(bundlePackage); |
| var syms = dojo.hostenv.getModuleSymbols(moduleName); |
| var modpath = syms.concat("nls").join("/"); |
| var parent; |
| |
| dojo.hostenv.searchLocalePath(tempLocale, availableFlatLocales, 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; |
| } |
| |
| if(availableFlatLocales){ |
| //Stop the locale path searching if we know the availableFlatLocales, since |
| //the first call to this function will load the only bundle that is needed. |
| return true; |
| } |
| }); |
| } |
| |
| //Save the best locale bundle as the target locale bundle when we know the |
| //the available bundles. |
| if(availableFlatLocales && targetLocale != bestLocale){ |
| bundle[targetLocale.replace('-', '_')] = bundle[bestLocale.replace('-', '_')]; |
| } |
| }; |
| |
| (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, availableFlatLocales){ |
| req(m,b,locale, availableFlatLocales); |
| if(locale){return;} |
| for(var i=0; i<extra.length; i++){ |
| req(m,b,extra[i], availableFlatLocales); |
| } |
| }; |
| } |
| })(); |
| |
| }; |
| |
| if(typeof window != 'undefined'){ |
| |
| // attempt to figure out the path to dojo if it isn't set in the config |
| (function(){ |
| // before we get any further with the config options, try to pick them out |
| // of the URL. Most of this code is from NW |
| if(djConfig.allowQueryConfig){ |
| var baseUrl = document.location.toString(); // FIXME: use location.query instead? |
| var params = baseUrl.split("?", 2); |
| if(params.length > 1){ |
| var paramStr = params[1]; |
| var pairs = paramStr.split("&"); |
| for(var x in pairs){ |
| var sp = pairs[x].split("="); |
| // FIXME: is this eval dangerous? |
| if((sp[0].length > 9)&&(sp[0].substr(0, 9) == "djConfig.")){ |
| var opt = sp[0].substr(9); |
| try{ |
| djConfig[opt]=eval(sp[1]); |
| }catch(e){ |
| djConfig[opt]=sp[1]; |
| } |
| } |
| } |
| } |
| } |
| |
| if( |
| ((djConfig["baseScriptUri"] == "")||(djConfig["baseRelativePath"] == "")) && |
| (document && document.getElementsByTagName) |
| ){ |
| var scripts = document.getElementsByTagName("script"); |
| var rePkg = /(__package__|dojo|bootstrap1)\.js([\?\.]|$)/i; |
| for(var i = 0; i < scripts.length; i++) { |
| var src = scripts[i].getAttribute("src"); |
| if(!src) { continue; } |
| var m = src.match(rePkg); |
| if(m) { |
| var root = src.substring(0, m.index); |
| if(src.indexOf("bootstrap1") > -1) { root += "../"; } |
| if(!this["djConfig"]) { djConfig = {}; } |
| if(djConfig["baseScriptUri"] == "") { djConfig["baseScriptUri"] = root; } |
| if(djConfig["baseRelativePath"] == "") { djConfig["baseRelativePath"] = root; } |
| break; |
| } |
| } |
| } |
| |
| // fill in the rendering support information in dojo.render.* |
| var dr = dojo.render; |
| var drh = dojo.render.html; |
| var drs = dojo.render.svg; |
| var dua = (drh.UA = navigator.userAgent); |
| var dav = (drh.AV = navigator.appVersion); |
| var t = true; |
| var f = false; |
| drh.capable = t; |
| drh.support.builtin = t; |
| |
| dr.ver = parseFloat(drh.AV); |
| dr.os.mac = dav.indexOf("Macintosh") >= 0; |
| dr.os.win = dav.indexOf("Windows") >= 0; |
| // could also be Solaris or something, but it's the same browser |
| dr.os.linux = dav.indexOf("X11") >= 0; |
| |
| drh.opera = dua.indexOf("Opera") >= 0; |
| drh.khtml = (dav.indexOf("Konqueror") >= 0)||(dav.indexOf("Safari") >= 0); |
| drh.safari = dav.indexOf("Safari") >= 0; |
| var geckoPos = dua.indexOf("Gecko"); |
| drh.mozilla = drh.moz = (geckoPos >= 0)&&(!drh.khtml); |
| if (drh.mozilla) { |
| // gecko version is YYYYMMDD |
| drh.geckoVersion = dua.substring(geckoPos + 6, geckoPos + 14); |
| } |
| drh.ie = (document.all)&&(!drh.opera); |
| drh.ie50 = drh.ie && dav.indexOf("MSIE 5.0")>=0; |
| drh.ie55 = drh.ie && dav.indexOf("MSIE 5.5")>=0; |
| drh.ie60 = drh.ie && dav.indexOf("MSIE 6.0")>=0; |
| drh.ie70 = drh.ie && dav.indexOf("MSIE 7.0")>=0; |
| |
| var cm = document["compatMode"]; |
| drh.quirks = (cm == "BackCompat")||(cm == "QuirksMode")||drh.ie55||drh.ie50; |
| |
| // TODO: is the HTML LANG attribute relevant? |
| dojo.locale = dojo.locale || (drh.ie ? navigator.userLanguage : navigator.language).toLowerCase(); |
| |
| dr.vml.capable=drh.ie; |
| drs.capable = f; |
| drs.support.plugin = f; |
| drs.support.builtin = f; |
| var tdoc = window["document"]; |
| var tdi = tdoc["implementation"]; |
| |
| if((tdi)&&(tdi["hasFeature"])&&(tdi.hasFeature("org.w3c.dom.svg", "1.0"))){ |
| drs.capable = t; |
| drs.support.builtin = t; |
| drs.support.plugin = f; |
| } |
| // webkits after 420 support SVG natively. The test string is "AppleWebKit/420+" |
| if(drh.safari){ |
| var tmp = dua.split("AppleWebKit/")[1]; |
| var ver = parseFloat(tmp.split(" ")[0]); |
| if(ver >= 420){ |
| drs.capable = t; |
| drs.support.builtin = t; |
| drs.support.plugin = f; |
| } |
| }else{ |
| } |
| })(); |
| |
| dojo.hostenv.startPackage("dojo.hostenv"); |
| |
| dojo.render.name = dojo.hostenv.name_ = 'browser'; |
| dojo.hostenv.searchIds = []; |
| |
| // These are in order of decreasing likelihood; this will change in time. |
| dojo.hostenv._XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0']; |
| |
| dojo.hostenv.getXmlhttpObject = function(){ |
| // summary: does the work of portably generating a new XMLHTTPRequest object. |
| var http = null; |
| var last_e = null; |
| try{ http = new XMLHttpRequest(); }catch(e){} |
| if(!http){ |
| for(var i=0; i<3; ++i){ |
| var progid = dojo.hostenv._XMLHTTP_PROGIDS[i]; |
| try{ |
| http = new ActiveXObject(progid); |
| }catch(e){ |
| last_e = e; |
| } |
| |
| if(http){ |
| dojo.hostenv._XMLHTTP_PROGIDS = [progid]; // so faster next time |
| break; |
| } |
| } |
| |
| /*if(http && !http.toString) { |
| http.toString = function() { "[object XMLHttpRequest]"; } |
| }*/ |
| } |
| |
| if(!http){ |
| return dojo.raise("XMLHTTP not available", last_e); |
| } |
| |
| return http; // XMLHTTPRequest instance |
| } |
| |
| dojo.hostenv._blockAsync = false; |
| dojo.hostenv.getText = function(uri, async_cb, fail_ok){ |
| // summary: Read the contents of the specified uri and return those contents. |
| // uri: |
| // A relative or absolute uri. If absolute, it still must be in |
| // the same "domain" as we are. |
| // async_cb: |
| // If not specified, load synchronously. If specified, load |
| // asynchronously, and use async_cb as the progress handler which |
| // takes the xmlhttp object as its argument. If async_cb, this |
| // function returns null. |
| // fail_ok: |
| // Default false. If fail_ok and !async_cb and loading fails, |
| // return null instead of throwing. |
| |
| // need to block async callbacks from snatching this thread as the result |
| // of an async callback might call another sync XHR, this hangs khtml forever |
| // hostenv._blockAsync must also be checked in BrowserIO's watchInFlight() |
| // NOTE: must be declared before scope switches ie. this.getXmlhttpObject() |
| if(!async_cb){ this._blockAsync = true; } |
| |
| var http = this.getXmlhttpObject(); |
| |
| function isDocumentOk(http){ |
| var stat = http["status"]; |
| // allow a 304 use cache, needed in konq (is this compliant with the http spec?) |
| return Boolean((!stat)||((200 <= stat)&&(300 > stat))||(stat==304)); |
| } |
| |
| if(async_cb){ |
| var _this = this, timer = null, gbl = dojo.global(); |
| var xhr = dojo.evalObjPath("dojo.io.XMLHTTPTransport"); |
| http.onreadystatechange = function(){ |
| if(timer){ gbl.clearTimeout(timer); timer = null; } |
| if(_this._blockAsync || (xhr && xhr._blockAsync)){ |
| timer = gbl.setTimeout(function () { http.onreadystatechange.apply(this); }, 10); |
| }else{ |
| if(4==http.readyState){ |
| if(isDocumentOk(http)){ |
| // dojo.debug("LOADED URI: "+uri); |
| async_cb(http.responseText); |
| } |
| } |
| } |
| } |
| } |
| |
| http.open('GET', uri, async_cb ? true : false); |
| try{ |
| http.send(null); |
| if(async_cb){ |
| return null; |
| } |
| if(!isDocumentOk(http)){ |
| var err = Error("Unable to load "+uri+" status:"+ http.status); |
| err.status = http.status; |
| err.responseText = http.responseText; |
| throw err; |
| } |
| }catch(e){ |
| this._blockAsync = false; |
| if((fail_ok)&&(!async_cb)){ |
| return null; |
| }else{ |
| throw e; |
| } |
| } |
| |
| this._blockAsync = false; |
| return http.responseText; // String |
| } |
| |
| dojo.hostenv.defaultDebugContainerId = 'dojoDebug'; |
| dojo.hostenv._println_buffer = []; |
| dojo.hostenv._println_safe = false; |
| dojo.hostenv.println = function(/*String*/line){ |
| // summary: |
| // prints the provided line to whatever logging container is |
| // available. If the page isn't loaded yet, the line may be added |
| // to a buffer for printing later. |
| if(!dojo.hostenv._println_safe){ |
| dojo.hostenv._println_buffer.push(line); |
| }else{ |
| try { |
| var console = document.getElementById(djConfig.debugContainerId ? |
| djConfig.debugContainerId : dojo.hostenv.defaultDebugContainerId); |
| if(!console) { console = dojo.body(); } |
| |
| var div = document.createElement("div"); |
| div.appendChild(document.createTextNode(line)); |
| console.appendChild(div); |
| } catch (e) { |
| try{ |
| // safari needs the output wrapped in an element for some reason |
| document.write("<div>" + line + "</div>"); |
| }catch(e2){ |
| window.status = line; |
| } |
| } |
| } |
| } |
| |
| dojo.addOnLoad(function(){ |
| dojo.hostenv._println_safe = true; |
| while(dojo.hostenv._println_buffer.length > 0){ |
| dojo.hostenv.println(dojo.hostenv._println_buffer.shift()); |
| } |
| }); |
| |
| function dj_addNodeEvtHdlr(/*DomNode*/node, /*String*/evtName, /*Function*/fp){ |
| // summary: |
| // non-destructively adds the specified function to the node's |
| // evtName handler. |
| // node: the DomNode to add the handler to |
| // evtName: should be in the form "click" for "onclick" handlers |
| var oldHandler = node["on"+evtName] || function(){}; |
| node["on"+evtName] = function(){ |
| fp.apply(node, arguments); |
| oldHandler.apply(node, arguments); |
| } |
| return true; |
| } |
| |
| dojo.hostenv._djInitFired = false; |
| // BEGIN DOMContentLoaded, from Dean Edwards (http://dean.edwards.name/weblog/2006/06/again/) |
| function dj_load_init(e){ |
| dojo.hostenv._djInitFired = true; |
| // allow multiple calls, only first one will take effect |
| // A bug in khtml calls events callbacks for document for event which isnt supported |
| // for example a created contextmenu event calls DOMContentLoaded, workaround |
| var type = (e && e.type) ? e.type.toLowerCase() : "load"; |
| if(arguments.callee.initialized || (type!="domcontentloaded" && type!="load")){ return; } |
| arguments.callee.initialized = true; |
| if(typeof(_timer) != 'undefined'){ |
| clearInterval(_timer); |
| delete _timer; |
| } |
| |
| var initFunc = function(){ |
| //perform initialization |
| if(dojo.render.html.ie){ |
| dojo.hostenv.makeWidgets(); |
| } |
| }; |
| |
| if(dojo.hostenv.inFlightCount == 0){ |
| initFunc(); |
| dojo.hostenv.modulesLoaded(); |
| }else{ |
| //This else case should be xdomain loading. |
| //Make sure this is the first thing in the load listener array. |
| //Part of the dojo.addOnLoad guarantee is that when the listeners are notified, |
| //It means the DOM (or page) has loaded and that widgets have been parsed. |
| dojo.hostenv.modulesLoadedListeners.unshift(initFunc); |
| } |
| } |
| |
| // START DOMContentLoaded |
| // Mozilla and Opera 9 expose the event we could use |
| if(document.addEventListener){ |
| // NOTE: |
| // due to a threading issue in Firefox 2.0, we can't enable |
| // DOMContentLoaded on that platform. For more information, see: |
| // http://trac.dojotoolkit.org/ticket/1704 |
| if(dojo.render.html.opera || (dojo.render.html.moz && (djConfig["enableMozDomContentLoaded"] === true))){ |
| document.addEventListener("DOMContentLoaded", dj_load_init, null); |
| } |
| |
| // mainly for Opera 8.5, won't be fired if DOMContentLoaded fired already. |
| // also used for Mozilla because of trac #1640 |
| window.addEventListener("load", dj_load_init, null); |
| } |
| |
| // for Internet Explorer. readyState will not be achieved on init call, but dojo doesn't need it |
| // however, we'll include it because we don't know if there are other functions added that might. |
| // Note that this has changed because the build process strips all comments--including conditional |
| // ones. |
| if(dojo.render.html.ie && dojo.render.os.win){ |
| document.attachEvent("onreadystatechange", function(e){ |
| if(document.readyState == "complete"){ |
| dj_load_init(); |
| } |
| }); |
| } |
| |
| if (/(WebKit|khtml)/i.test(navigator.userAgent)) { // sniff |
| var _timer = setInterval(function() { |
| if (/loaded|complete/.test(document.readyState)) { |
| dj_load_init(); // call the onload handler |
| } |
| }, 10); |
| } |
| // END DOMContentLoaded |
| |
| // IE WebControl hosted in an application can fire "beforeunload" and "unload" |
| // events when control visibility changes, causing Dojo to unload too soon. The |
| // following code fixes the problem |
| // Reference: http://support.microsoft.com/default.aspx?scid=kb;en-us;199155 |
| if(dojo.render.html.ie){ |
| dj_addNodeEvtHdlr(window, "beforeunload", function(){ |
| dojo.hostenv._unloading = true; |
| window.setTimeout(function() { |
| dojo.hostenv._unloading = false; |
| }, 0); |
| }); |
| } |
| |
| dj_addNodeEvtHdlr(window, "unload", function(){ |
| dojo.hostenv.unloaded(); |
| if((!dojo.render.html.ie)||(dojo.render.html.ie && dojo.hostenv._unloading)){ |
| dojo.hostenv.unloaded(); |
| } |
| }); |
| |
| dojo.hostenv.makeWidgets = function(){ |
| // you can put searchIds in djConfig and dojo.hostenv at the moment |
| // we should probably eventually move to one or the other |
| var sids = []; |
| if(djConfig.searchIds && djConfig.searchIds.length > 0) { |
| sids = sids.concat(djConfig.searchIds); |
| } |
| if(dojo.hostenv.searchIds && dojo.hostenv.searchIds.length > 0) { |
| sids = sids.concat(dojo.hostenv.searchIds); |
| } |
| |
| if((djConfig.parseWidgets)||(sids.length > 0)){ |
| if(dojo.evalObjPath("dojo.widget.Parse")){ |
| // we must do this on a delay to avoid: |
| // http://www.shaftek.org/blog/archives/000212.html |
| // (IE bug) |
| var parser = new dojo.xml.Parse(); |
| if(sids.length > 0){ |
| for(var x=0; x<sids.length; x++){ |
| var tmpNode = document.getElementById(sids[x]); |
| if(!tmpNode){ continue; } |
| var frag = parser.parseElement(tmpNode, null, true); |
| dojo.widget.getParser().createComponents(frag); |
| } |
| }else if(djConfig.parseWidgets){ |
| var frag = parser.parseElement(dojo.body(), null, true); |
| dojo.widget.getParser().createComponents(frag); |
| } |
| } |
| } |
| } |
| |
| dojo.addOnLoad(function(){ |
| if(!dojo.render.html.ie) { |
| dojo.hostenv.makeWidgets(); |
| } |
| }); |
| |
| try{ |
| if(dojo.render.html.ie){ |
| document.namespaces.add("v","urn:schemas-microsoft-com:vml"); |
| document.createStyleSheet().addRule("v\\:*", "behavior:url(#default#VML)"); |
| } |
| }catch(e){ } |
| |
| // stub, over-ridden by debugging code. This will at least keep us from |
| // breaking when it's not included |
| dojo.hostenv.writeIncludes = function(){} |
| |
| //TODOC: HOW TO DOC THIS? |
| // @global: dj_currentDocument |
| // summary: |
| // Current document object. 'dj_currentDocument' can be modified for temporary context shifting. |
| // description: |
| // dojo.doc() returns dojo.currentDocument. |
| // Refer to dojo.doc() rather than referring to 'window.document' to ensure your |
| // code runs correctly in managed contexts. |
| if(!dj_undef("document", this)){ |
| dj_currentDocument = this.document; |
| } |
| |
| dojo.doc = function(){ |
| // summary: |
| // return the document object associated with the dojo.global() |
| return dj_currentDocument; |
| } |
| |
| dojo.body = function(){ |
| // summary: |
| // return the body object associated with dojo.doc() |
| // Note: document.body is not defined for a strict xhtml document |
| return dojo.doc().body || dojo.doc().getElementsByTagName("body")[0]; |
| } |
| |
| dojo.byId = function(/*String*/id, /*DocumentElement*/doc){ |
| // summary: |
| // similar to other library's "$" function, takes a string |
| // representing a DOM id or a DomNode and returns the |
| // corresponding DomNode. If a Node is passed, this function is a |
| // no-op. Returns a single DOM node or null, working around |
| // several browser-specific bugs to do so. |
| // id: DOM id or DOM Node |
| // doc: |
| // optional, defaults to the current value of dj_currentDocument. |
| // Can be used to retreive node references from other documents. |
| if((id)&&((typeof id == "string")||(id instanceof String))){ |
| if(!doc){ doc = dj_currentDocument; } |
| var ele = doc.getElementById(id); |
| // workaround bug in IE and Opera 8.2 where getElementById returns wrong element |
| if(ele && (ele.id != id) && doc.all){ |
| ele = null; |
| // get all matching elements with this id |
| eles = doc.all[id]; |
| if(eles){ |
| // if more than 1, choose first with the correct id |
| if(eles.length){ |
| for(var i=0; i<eles.length; i++){ |
| if(eles[i].id == id){ |
| ele = eles[i]; |
| break; |
| } |
| } |
| // return 1 and only element |
| }else{ |
| ele = eles; |
| } |
| } |
| } |
| return ele; // DomNode |
| } |
| return id; // DomNode |
| } |
| |
| dojo.setContext = function(/*Object*/globalObject, /*DocumentElement*/globalDocument){ |
| // summary: |
| // changes the behavior of many core Dojo functions that deal with |
| // namespace and DOM lookup, changing them to work in a new global |
| // context. The varibles dj_currentContext and dj_currentDocument |
| // are modified as a result of calling this function. |
| dj_currentContext = globalObject; |
| dj_currentDocument = globalDocument; |
| }; |
| |
| dojo._fireCallback = function(callback, context, cbArguments){ |
| if((context)&&((typeof callback == "string")||(callback instanceof String))){ |
| callback=context[callback]; |
| } |
| return (context ? callback.apply(context, cbArguments || [ ]) : callback()); |
| } |
| |
| dojo.withGlobal = function(/*Object*/globalObject, /*Function*/callback, /*Object?*/thisObject, /*Array?*/cbArguments){ |
| // summary: |
| // Call callback with globalObject as dojo.global() and globalObject.document |
| // as dojo.doc(). If provided, globalObject will be executed in the context of |
| // object thisObject |
| // description: |
| // When callback() returns or throws an error, the dojo.global() and dojo.doc() will |
| // be restored to its previous state. |
| var rval; |
| var oldGlob = dj_currentContext; |
| var oldDoc = dj_currentDocument; |
| try{ |
| dojo.setContext(globalObject, globalObject.document); |
| rval = dojo._fireCallback(callback, thisObject, cbArguments); |
| }finally{ |
| dojo.setContext(oldGlob, oldDoc); |
| } |
| return rval; |
| } |
| |
| dojo.withDoc = function (/*Object*/documentObject, /*Function*/callback, /*Object?*/thisObject, /*Array?*/cbArguments) { |
| // summary: |
| // Call callback with documentObject as dojo.doc(). If provided, callback will be executed |
| // in the context of object thisObject |
| // description: |
| // When callback() returns or throws an error, the dojo.doc() will |
| // be restored to its previous state. |
| var rval; |
| var oldDoc = dj_currentDocument; |
| try{ |
| dj_currentDocument = documentObject; |
| rval = dojo._fireCallback(callback, thisObject, cbArguments); |
| }finally{ |
| dj_currentDocument = oldDoc; |
| } |
| return rval; |
| } |
| |
| } //if (typeof window != 'undefined') |
| |
| //Load debug code if necessary. |
| dojo.requireIf((djConfig["isDebug"] || djConfig["debugAtAllCosts"]), "dojo.debug"); |
| |
| //window.widget is for Dashboard detection |
| //The full conditionals are spelled out to avoid issues during builds. |
| //Builds may be looking for require/requireIf statements and processing them. |
| dojo.requireIf(djConfig["debugAtAllCosts"] && !window.widget && !djConfig["useXDomain"], "dojo.browser_debug"); |
| dojo.requireIf(djConfig["debugAtAllCosts"] && !window.widget && djConfig["useXDomain"], "dojo.browser_debug_xd"); |
| |
| dojo.provide("dojo.string.common"); |
| |
| dojo.string.trim = function(/* string */str, /* integer? */wh){ |
| // summary |
| // Trim whitespace from str. If wh > 0, trim from start, if wh < 0, trim from end, else both |
| if(!str.replace){ return str; } |
| if(!str.length){ return str; } |
| var re = (wh > 0) ? (/^\s+/) : (wh < 0) ? (/\s+$/) : (/^\s+|\s+$/g); |
| return str.replace(re, ""); // string |
| } |
| |
| dojo.string.trimStart = function(/* string */str) { |
| // summary |
| // Trim whitespace at the beginning of 'str' |
| return dojo.string.trim(str, 1); // string |
| } |
| |
| dojo.string.trimEnd = function(/* string */str) { |
| // summary |
| // Trim whitespace at the end of 'str' |
| return dojo.string.trim(str, -1); |
| } |
| |
| dojo.string.repeat = function(/* string */str, /* integer */count, /* string? */separator) { |
| // summary |
| // Return 'str' repeated 'count' times, optionally placing 'separator' between each rep |
| var out = ""; |
| for(var i = 0; i < count; i++) { |
| out += str; |
| if(separator && i < count - 1) { |
| out += separator; |
| } |
| } |
| return out; // string |
| } |
| |
| dojo.string.pad = function(/* string */str, /* integer */len/*=2*/, /* string */ c/*='0'*/, /* integer */dir/*=1*/) { |
| // summary |
| // Pad 'str' to guarantee that it is at least 'len' length with the character 'c' at either the |
| // start (dir=1) or end (dir=-1) of the string |
| var out = String(str); |
| if(!c) { |
| c = '0'; |
| } |
| if(!dir) { |
| dir = 1; |
| } |
| while(out.length < len) { |
| if(dir > 0) { |
| out = c + out; |
| } else { |
| out += c; |
| } |
| } |
| return out; // string |
| } |
| |
| dojo.string.padLeft = function(/* string */str, /* integer */len, /* string */c) { |
| // summary |
| // same as dojo.string.pad(str, len, c, 1) |
| return dojo.string.pad(str, len, c, 1); // string |
| } |
| |
| dojo.string.padRight = function(/* string */str, /* integer */len, /* string */c) { |
| // summary |
| // same as dojo.string.pad(str, len, c, -1) |
| return dojo.string.pad(str, len, c, -1); // string |
| } |
| |
| dojo.provide("dojo.string"); |
| |
| |
| dojo.provide("dojo.lang.common"); |
| |
| dojo.lang.inherits = function(/*Function*/subclass, /*Function*/superclass){ |
| // summary: Set up inheritance between two classes. |
| if(!dojo.lang.isFunction(superclass)){ |
| dojo.raise("dojo.inherits: superclass argument ["+superclass+"] must be a function (subclass: ["+subclass+"']"); |
| } |
| subclass.prototype = new superclass(); |
| subclass.prototype.constructor = subclass; |
| subclass.superclass = superclass.prototype; |
| // DEPRECATED: super is a reserved word, use 'superclass' |
| subclass['super'] = superclass.prototype; |
| } |
| |
| dojo.lang._mixin = function(/*Object*/ obj, /*Object*/ props){ |
| // summary: |
| // Adds all properties and methods of props to obj. This addition is |
| // "prototype extension safe", so that instances of objects will not |
| // pass along prototype defaults. |
| var tobj = {}; |
| for(var x in props){ |
| // the "tobj" condition avoid copying properties in "props" |
| // inherited from Object.prototype. For example, if obj has a custom |
| // toString() method, don't overwrite it with the toString() method |
| // that props inherited from Object.protoype |
| if((typeof tobj[x] == "undefined") || (tobj[x] != props[x])){ |
| obj[x] = props[x]; |
| } |
| } |
| // IE doesn't recognize custom toStrings in for..in |
| if(dojo.render.html.ie |
| && (typeof(props["toString"]) == "function") |
| && (props["toString"] != obj["toString"]) |
| && (props["toString"] != tobj["toString"])) |
| { |
| obj.toString = props.toString; |
| } |
| return obj; // Object |
| } |
| |
| dojo.lang.mixin = function(/*Object*/obj, /*Object...*/props){ |
| // summary: Adds all properties and methods of props to obj. |
| for(var i=1, l=arguments.length; i<l; i++){ |
| dojo.lang._mixin(obj, arguments[i]); |
| } |
| return obj; // Object |
| } |
| |
| dojo.lang.extend = function(/*Object*/ constructor, /*Object...*/ props){ |
| // summary: |
| // Adds all properties and methods of props to constructor's |
| // prototype, making them available to all instances created with |
| // constructor. |
| for(var i=1, l=arguments.length; i<l; i++){ |
| dojo.lang._mixin(constructor.prototype, arguments[i]); |
| } |
| return constructor; // Object |
| } |
| |
| // Promote to dojo module |
| dojo.inherits = dojo.lang.inherits; |
| //dojo.lang._mixin = dojo.lang._mixin; |
| dojo.mixin = dojo.lang.mixin; |
| dojo.extend = dojo.lang.extend; |
| |
| dojo.lang.find = function( /*Array*/ array, |
| /*Object*/ value, |
| /*Boolean?*/ identity, |
| /*Boolean?*/ findLast){ |
| // summary: |
| // Return the index of value in array, returning -1 if not found. |
| // array: just what you think |
| // value: the value to locate |
| // identity: |
| // If true, matches with identity comparison (===). If false, uses |
| // normal comparison (==). |
| // findLast: |
| // If true, returns index of last instance of value. |
| // examples: |
| // find(array, value[, identity [findLast]]) // recommended |
| // find(value, array[, identity [findLast]]) // deprecated |
| |
| // support both (array, value) and (value, array) |
| if(!dojo.lang.isArrayLike(array) && dojo.lang.isArrayLike(value)) { |
| dojo.deprecated('dojo.lang.find(value, array)', 'use dojo.lang.find(array, value) instead', "0.5"); |
| var temp = array; |
| array = value; |
| value = temp; |
| } |
| var isString = dojo.lang.isString(array); |
| if(isString) { array = array.split(""); } |
| |
| if(findLast) { |
| var step = -1; |
| var i = array.length - 1; |
| var end = -1; |
| } else { |
| var step = 1; |
| var i = 0; |
| var end = array.length; |
| } |
| if(identity){ |
| while(i != end) { |
| if(array[i] === value){ return i; } |
| i += step; |
| } |
| }else{ |
| while(i != end) { |
| if(array[i] == value){ return i; } |
| i += step; |
| } |
| } |
| return -1; // number |
| } |
| |
| dojo.lang.indexOf = dojo.lang.find; |
| |
| dojo.lang.findLast = function(/*Array*/array, /*Object*/value, /*boolean?*/identity){ |
| // summary: |
| // Return index of last occurance of value in array, returning -1 if |
| // not found. This is a shortcut for dojo.lang.find() with a true |
| // value for its "findLast" parameter. |
| // identity: |
| // If true, matches with identity comparison (===). If false, uses |
| // normal comparison (==). |
| return dojo.lang.find(array, value, identity, true); // number |
| } |
| |
| dojo.lang.lastIndexOf = dojo.lang.findLast; |
| |
| dojo.lang.inArray = function(array /*Array*/, value /*Object*/){ |
| // summary: Return true if value is present in array. |
| return dojo.lang.find(array, value) > -1; // boolean |
| } |
| |
| /** |
| * Partial implmentation of is* functions from |
| * http://www.crockford.com/javascript/recommend.html |
| * NOTE: some of these may not be the best thing to use in all situations |
| * as they aren't part of core JS and therefore can't work in every case. |
| * See WARNING messages inline for tips. |
| * |
| * The following is* functions are fairly "safe" |
| */ |
| |
| dojo.lang.isObject = function(/*anything*/ it){ |
| // summary: Return true if it is an Object, Array or Function. |
| if(typeof it == "undefined"){ return false; } |
| return (typeof it == "object" || it === null || dojo.lang.isArray(it) || dojo.lang.isFunction(it)); // Boolean |
| } |
| |
| dojo.lang.isArray = function(/*anything*/ it){ |
| // summary: Return true if it is an Array. |
| return (it && it instanceof Array || typeof it == "array"); // Boolean |
| } |
| |
| dojo.lang.isArrayLike = function(/*anything*/ it){ |
| // summary: |
| // Return true if it can be used as an array (i.e. is an object with |
| // an integer length property). |
| if((!it)||(dojo.lang.isUndefined(it))){ return false; } |
| if(dojo.lang.isString(it)){ return false; } |
| if(dojo.lang.isFunction(it)){ return false; } // keeps out built-in constructors (Number, String, ...) which have length properties |
| if(dojo.lang.isArray(it)){ return true; } |
| // form node itself is ArrayLike, but not always iterable. Use form.elements instead. |
| if((it.tagName)&&(it.tagName.toLowerCase()=='form')){ return false; } |
| if(dojo.lang.isNumber(it.length) && isFinite(it.length)){ return true; } |
| return false; // Boolean |
| } |
| |
| dojo.lang.isFunction = function(/*anything*/ it){ |
| // summary: Return true if it is a Function. |
| return (it instanceof Function || typeof it == "function"); // Boolean |
| }; |
| |
| (function(){ |
| // webkit treats NodeList as a function, which is bad |
| if((dojo.render.html.capable)&&(dojo.render.html["safari"])){ |
| dojo.lang.isFunction = function(/*anything*/ it){ |
| if((typeof(it) == "function") && (it == "[object NodeList]")) { return false; } |
| return (it instanceof Function || typeof it == "function"); // Boolean |
| } |
| } |
| })(); |
| |
| dojo.lang.isString = function(/*anything*/ it){ |
| // summary: Return true if it is a String. |
| return (typeof it == "string" || it instanceof String); |
| } |
| |
| dojo.lang.isAlien = function(/*anything*/ it){ |
| // summary: Return true if it is not a built-in function. False if not. |
| if(!it){ return false; } |
| return !dojo.lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean |
| } |
| |
| dojo.lang.isBoolean = function(/*anything*/ it){ |
| // summary: Return true if it is a Boolean. |
| return (it instanceof Boolean || typeof it == "boolean"); // Boolean |
| } |
| |
| /** |
| * The following is***() functions are somewhat "unsafe". Fortunately, |
| * there are workarounds the the language provides and are mentioned |
| * in the WARNING messages. |
| * |
| */ |
| dojo.lang.isNumber = function(/*anything*/ it){ |
| // summary: Return true if it is a number. |
| // description: |
| // WARNING - In most cases, isNaN(it) is sufficient to determine whether or not |
| // something is a number or can be used as such. For example, a number or string |
| // can be used interchangably when accessing array items (array["1"] is the same as |
| // array[1]) and isNaN will return false for both values ("1" and 1). However, |
| // isNumber("1") will return false, which is generally not too useful. |
| // Also, isNumber(NaN) returns true, again, this isn't generally useful, but there |
| // are corner cases (like when you want to make sure that two things are really |
| // the same type of thing). That is really where isNumber "shines". |
| // |
| // Recommendation - Use isNaN(it) when possible |
| |
| return (it instanceof Number || typeof it == "number"); // Boolean |
| } |
| |
| /* |
| * FIXME: Should isUndefined go away since it is error prone? |
| */ |
| dojo.lang.isUndefined = function(/*anything*/ it){ |
| // summary: Return true if it is not defined. |
| // description: |
| // WARNING - In some cases, isUndefined will not behave as you |
| // might expect. If you do isUndefined(foo) and there is no earlier |
| // reference to foo, an error will be thrown before isUndefined is |
| // called. It behaves correctly if you scope yor object first, i.e. |
| // isUndefined(foo.bar) where foo is an object and bar isn't a |
| // property of the object. |
| // |
| // Recommendation - Use typeof foo == "undefined" when possible |
| |
| return ((typeof(it) == "undefined")&&(it == undefined)); // Boolean |
| } |
| |
| // end Crockford functions |
| |
| dojo.provide("dojo.lang.extras"); |
| |
| |
| |
| dojo.lang.setTimeout = function(/*Function*/func, /*int*/delay /*, ...*/){ |
| // summary: |
| // Sets a timeout in milliseconds to execute a function in a given |
| // context with optional arguments. |
| // usage: |
| // dojo.lang.setTimeout(Object context, function func, number delay[, arg1[, ...]]); |
| // dojo.lang.setTimeout(function func, number delay[, arg1[, ...]]); |
| |
| var context = window, argsStart = 2; |
| if(!dojo.lang.isFunction(func)){ |
| context = func; |
| func = delay; |
| delay = arguments[2]; |
| argsStart++; |
| } |
| |
| if(dojo.lang.isString(func)){ |
| func = context[func]; |
| } |
| |
| var args = []; |
| for (var i = argsStart; i < arguments.length; i++){ |
| args.push(arguments[i]); |
| } |
| return dojo.global().setTimeout(function(){ func.apply(context, args); }, delay); // int |
| } |
| |
| dojo.lang.clearTimeout = function(/*int*/timer){ |
| // summary: clears timer by number from the execution queue |
| |
| // FIXME: |
| // why do we have this function? It's not portable outside of browser |
| // environments and it's a stupid wrapper on something that browsers |
| // provide anyway. |
| dojo.global().clearTimeout(timer); |
| } |
| |
| dojo.lang.getNameInObj = function(/*Object*/ns, /*unknown*/item){ |
| // summary: |
| // looks for a value in the object ns with a value matching item and |
| // returns the property name |
| // ns: if null, dj_global is used |
| // item: value to return a name for |
| if(!ns){ ns = dj_global; } |
| |
| for(var x in ns){ |
| if(ns[x] === item){ |
| return new String(x); // String |
| } |
| } |
| return null; // null |
| } |
| |
| dojo.lang.shallowCopy = function(/*Object*/obj, /*Boolean?*/deep){ |
| // summary: |
| // copies object obj one level deep, or full depth if deep is true |
| var i, ret; |
| |
| if(obj === null){ /*obj: null*/ return null; } // null |
| |
| if(dojo.lang.isObject(obj)){ |
| // obj: Object |
| ret = new obj.constructor(); |
| for(i in obj){ |
| if(dojo.lang.isUndefined(ret[i])){ |
| ret[i] = deep ? dojo.lang.shallowCopy(obj[i], deep) : obj[i]; |
| } |
| } |
| }else if(dojo.lang.isArray(obj)){ |
| // obj: Array |
| ret = []; |
| for(i=0; i<obj.length; i++){ |
| ret[i] = deep ? dojo.lang.shallowCopy(obj[i], deep) : obj[i]; |
| } |
| }else{ |
| // obj: Object |
| ret = obj; |
| } |
| |
| return ret; // Object |
| } |
| |
| dojo.lang.firstValued = function(/* ... */){ |
| // summary: Return the first argument that isn't undefined |
| |
| for(var i = 0; i < arguments.length; i++){ |
| if(typeof arguments[i] != "undefined"){ |
| return arguments[i]; // Object |
| } |
| } |
| return undefined; // undefined |
| } |
| |
| dojo.lang.getObjPathValue = function(/*String*/objpath, /*Object?*/context, /*Boolean?*/create){ |
| // summary: |
| // Gets a value from a reference specified as a string descriptor, |
| // (e.g. "A.B") in the given context. |
| // context: if not specified, dj_global is used |
| // create: if true, undefined objects in the path are created. |
| with(dojo.parseObjPath(objpath, context, create)){ |
| return dojo.evalProp(prop, obj, create); // Object |
| } |
| } |
| |
| dojo.lang.setObjPathValue = function(/*String*/objpath, /*anything*/value, /*Object?*/context, /*Boolean?*/create){ |
| // summary: |
| // Sets a value on a reference specified as a string descriptor. |
| // (e.g. "A.B") in the given context. This is similar to straight |
| // assignment, except that the object structure in question can |
| // optionally be created if it does not exist. |
| // context: if not specified, dj_global is used |
| // create: if true, undefined objects in the path are created. |
| |
| // FIXME: why is this function valuable? It should be scheduled for |
| // removal on the grounds that dojo.parseObjPath does most of it's work and |
| // is more straightforward and has fewer dependencies. Also, the order of |
| // arguments is bone-headed. "context" should clearly come after "create". |
| // *sigh* |
| dojo.deprecated("dojo.lang.setObjPathValue", "use dojo.parseObjPath and the '=' operator", "0.6"); |
| |
| if(arguments.length < 4){ |
| create = true; |
| } |
| with(dojo.parseObjPath(objpath, context, create)){ |
| if(obj && (create || (prop in obj))){ |
| obj[prop] = value; |
| } |
| } |
| } |
| |
| dojo.provide("dojo.io.common"); |
| |
| |
| |
| /****************************************************************************** |
| * Notes about dojo.io design: |
| * |
| * The dojo.io.* package has the unenviable task of making a lot of different |
| * types of I/O feel natural, despite a universal lack of good (or even |
| * reasonable!) I/O capability in the host environment. So lets pin this down |
| * a little bit further. |
| * |
| * Rhino: |
| * perhaps the best situation anywhere. Access to Java classes allows you |
| * to do anything one might want in terms of I/O, both synchronously and |
| * async. Can open TCP sockets and perform low-latency client/server |
| * interactions. HTTP transport is available through Java HTTP client and |
| * server classes. Wish it were always this easy. |
| * |
| * xpcshell: |
| * XPCOM for I/O. |
| * |
| * spidermonkey: |
| * S.O.L. |
| * |
| * Browsers: |
| * Browsers generally do not provide any useable filesystem access. We are |
| * therefore limited to HTTP for moving information to and from Dojo |
| * instances living in a browser. |
| * |
| * XMLHTTP: |
| * Sync or async, allows reading of arbitrary text files (including |
| * JS, which can then be eval()'d), writing requires server |
| * cooperation and is limited to HTTP mechanisms (POST and GET). |
| * |
| * <iframe> hacks: |
| * iframe document hacks allow browsers to communicate asynchronously |
| * with a server via HTTP POST and GET operations. With significant |
| * effort and server cooperation, low-latency data transit between |
| * client and server can be acheived via iframe mechanisms (repubsub). |
| * |
| * SVG: |
| * Adobe's SVG viewer implements helpful primitives for XML-based |
| * requests, but receipt of arbitrary text data seems unlikely w/o |
| * <![CDATA[]]> sections. |
| * |
| * |
| * A discussion between Dylan, Mark, Tom, and Alex helped to lay down a lot |
| * the IO API interface. A transcript of it can be found at: |
| * http://dojotoolkit.org/viewcvs/viewcvs.py/documents/irc/irc_io_api_log.txt?rev=307&view=auto |
| * |
| * Also referenced in the design of the API was the DOM 3 L&S spec: |
| * http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/load-save.html |
| ******************************************************************************/ |
| |
| // a map of the available transport options. Transports should add themselves |
| // by calling add(name) |
| dojo.io.transports = []; |
| dojo.io.hdlrFuncNames = [ "load", "error", "timeout" ]; // we're omitting a progress() event for now |
| |
| dojo.io.Request = function(/*String*/ url, /*String*/ mimetype, /*String*/ transport, /*String or Boolean*/ changeUrl){ |
| // summary: |
| // Constructs a Request object that is used by dojo.io.bind(). |
| // description: |
| // dojo.io.bind() will create one of these for you if |
| // you call dojo.io.bind() with an plain object containing the bind parameters. |
| // This method can either take the arguments specified, or an Object containing all of the parameters that you |
| // want to use to create the dojo.io.Request (similar to how dojo.io.bind() is called. |
| // The named parameters to this constructor represent the minimum set of parameters need |
| if((arguments.length == 1)&&(arguments[0].constructor == Object)){ |
| this.fromKwArgs(arguments[0]); |
| }else{ |
| this.url = url; |
| if(mimetype){ this.mimetype = mimetype; } |
| if(transport){ this.transport = transport; } |
| if(arguments.length >= 4){ this.changeUrl = changeUrl; } |
| } |
| } |
| |
| dojo.lang.extend(dojo.io.Request, { |
| |
| /** The URL to hit */ |
| url: "", |
| |
| /** The mime type used to interrpret the response body */ |
| mimetype: "text/plain", |
| |
| /** The HTTP method to use */ |
| method: "GET", |
| |
| /** An Object containing key-value pairs to be included with the request */ |
| content: undefined, // Object |
| |
| /** The transport medium to use */ |
| transport: undefined, // String |
| |
| /** If defined the URL of the page is physically changed */ |
| changeUrl: undefined, // String |
| |
| /** A form node to use in the request */ |
| formNode: undefined, // HTMLFormElement |
| |
| /** Whether the request should be made synchronously */ |
| sync: false, |
| |
| bindSuccess: false, |
| |
| /** Cache/look for the request in the cache before attempting to request? |
| * NOTE: this isn't a browser cache, this is internal and would only cache in-page |
| */ |
| useCache: false, |
| |
| /** Prevent the browser from caching this by adding a query string argument to the URL */ |
| preventCache: false, |
| |
| jsonFilter: function(value){ |
| if( (this.mimetype == "text/json-comment-filtered")|| |
| (this.mimetype == "application/json-comment-filtered") |
| ){ |
| var cStartIdx = value.indexOf("\/*"); |
| var cEndIdx = value.lastIndexOf("*\/"); |
| if((cStartIdx == -1)||(cEndIdx == -1)){ |
| dojo.debug("your JSON wasn't comment filtered!"); // FIXME: throw exception instead? |
| return ""; |
| } |
| return value.substring(cStartIdx+2, cEndIdx); |
| } |
| dojo.debug("please consider using a mimetype of text/json-comment-filtered to avoid potential security issues with JSON endpoints"); |
| return value; |
| }, |
| |
| // events stuff |
| load: function(/*String*/type, /*Object*/data, /*Object*/transportImplementation, /*Object*/kwArgs){ |
| // summary: |
| // Called on successful completion of a bind. |
| // type: String |
| // A string with value "load" |
| // data: Object |
| // The object representing the result of the bind. The actual structure |
| // of the data object will depend on the mimetype that was given to bind |
| // in the bind arguments. |
| // transportImplementation: Object |
| // The object that implements a particular transport. Structure is depedent |
| // on the transport. For XMLHTTPTransport (dojo.io.BrowserIO), it will be the |
| // XMLHttpRequest object from the browser. |
| // kwArgs: Object |
| // Object that contains the request parameters that were given to the |
| // bind call. Useful for storing and retrieving state from when bind |
| // was called. |
| }, |
| error: function(/*String*/type, /*Object*/error, /*Object*/transportImplementation, /*Object*/kwArgs){ |
| // summary: |
| // Called when there is an error with a bind. |
| // type: String |
| // A string with value "error" |
| // error: Object |
| // The error object. Should be a dojo.io.Error object, but not guaranteed. |
| // transportImplementation: Object |
| // The object that implements a particular transport. Structure is depedent |
| // on the transport. For XMLHTTPTransport (dojo.io.BrowserIO), it will be the |
| // XMLHttpRequest object from the browser. |
| // kwArgs: Object |
| // Object that contains the request parameters that were given to the |
| // bind call. Useful for storing and retrieving state from when bind |
| // was called. |
| }, |
| timeout: function(/*String*/type, /*Object*/empty, /*Object*/transportImplementation, /*Object*/kwArgs){ |
| // summary: |
| // Called when there is an error with a bind. Only implemented in certain transports at this time. |
| // type: String |
| // A string with value "timeout" |
| // empty: Object |
| // Should be null. Just a spacer argument so that load, error, timeout and handle have the |
| // same signatures. |
| // transportImplementation: Object |
| // The object that implements a particular transport. Structure is depedent |
| // on the transport. For XMLHTTPTransport (dojo.io.BrowserIO), it will be the |
| // XMLHttpRequest object from the browser. May be null for the timeout case for |
| // some transports. |
| // kwArgs: Object |
| // Object that contains the request parameters that were given to the |
| // bind call. Useful for storing and retrieving state from when bind |
| // was called. |
| }, |
| handle: function(/*String*/type, /*Object*/data, /*Object*/transportImplementation, /*Object*/kwArgs){ |
| // summary: |
| // The handle method can be defined instead of defining separate load, error and timeout |
| // callbacks. |
| // type: String |
| // A string with the type of callback: "load", "error", or "timeout". |
| // data: Object |
| // See the above callbacks for what this parameter could be. |
| // transportImplementation: Object |
| // The object that implements a particular transport. Structure is depedent |
| // on the transport. For XMLHTTPTransport (dojo.io.BrowserIO), it will be the |
| // XMLHttpRequest object from the browser. |
| // kwArgs: Object |
| // Object that contains the request parameters that were given to the |
| // bind call. Useful for storing and retrieving state from when bind |
| // was called. |
| }, |
| |
| //FIXME: change IframeIO.js to use timeouts? |
| // The number of seconds to wait until firing a timeout callback. |
| // If it is zero, that means, don't do a timeout check. |
| timeoutSeconds: 0, |
| |
| // the abort method needs to be filled in by the transport that accepts the |
| // bind() request |
| abort: function(){ }, |
| |
| // backButton: function(){ }, |
| // forwardButton: function(){ }, |
| |
| fromKwArgs: function(/*Object*/ kwArgs){ |
| // summary: |
| // Creates a dojo.io.Request from a simple object (kwArgs object). |
| |
| // normalize args |
| if(kwArgs["url"]){ kwArgs.url = kwArgs.url.toString(); } |
| if(kwArgs["formNode"]) { kwArgs.formNode = dojo.byId(kwArgs.formNode); } |
| if(!kwArgs["method"] && kwArgs["formNode"] && kwArgs["formNode"].method) { |
| kwArgs.method = kwArgs["formNode"].method; |
| } |
| |
| // backwards compatibility |
| if(!kwArgs["handle"] && kwArgs["handler"]){ kwArgs.handle = kwArgs.handler; } |
| if(!kwArgs["load"] && kwArgs["loaded"]){ kwArgs.load = kwArgs.loaded; } |
| if(!kwArgs["changeUrl"] && kwArgs["changeURL"]) { kwArgs.changeUrl = kwArgs.changeURL; } |
| |
| // encoding fun! |
| kwArgs.encoding = dojo.lang.firstValued(kwArgs["encoding"], djConfig["bindEncoding"], ""); |
| |
| kwArgs.sendTransport = dojo.lang.firstValued(kwArgs["sendTransport"], djConfig["ioSendTransport"], false); |
| |
| var isFunction = dojo.lang.isFunction; |
| for(var x=0; x<dojo.io.hdlrFuncNames.length; x++){ |
| var fn = dojo.io.hdlrFuncNames[x]; |
| if(kwArgs[fn] && isFunction(kwArgs[fn])){ continue; } |
| if(kwArgs["handle"] && isFunction(kwArgs["handle"])){ |
| kwArgs[fn] = kwArgs.handle; |
| } |
| // handler is aliased above, shouldn't need this check |
| /* else if(dojo.lang.isObject(kwArgs.handler)){ |
| if(isFunction(kwArgs.handler[fn])){ |
| kwArgs[fn] = kwArgs.handler[fn]||kwArgs.handler["handle"]||function(){}; |
| } |
| }*/ |
| } |
| dojo.lang.mixin(this, kwArgs); |
| } |
| |
| }); |
| |
| dojo.io.Error = function(/*String*/ msg, /*String*/ type, /*Number*/num){ |
| // summary: |
| // Constructs an object representing a bind error. |
| this.message = msg; |
| this.type = type || "unknown"; // must be one of "io", "parse", "unknown" |
| this.number = num || 0; // per-substrate error number, not normalized |
| } |
| |
| dojo.io.transports.addTransport = function(/*String*/name){ |
| // summary: |
| // Used to register transports that can support bind calls. |
| this.push(name); |
| // FIXME: do we need to handle things that aren't direct children of the |
| // dojo.io module? (say, dojo.io.foo.fooTransport?) |
| this[name] = dojo.io[name]; |
| } |
| |
| // binding interface, the various implementations register their capabilities |
| // and the bind() method dispatches |
| dojo.io.bind = function(/*dojo.io.Request or Object*/request){ |
| // summary: |
| // Binding interface for IO. Loading different IO transports, like |
| // dojo.io.BrowserIO or dojo.io.IframeIO, will register with bind |
| // to handle particular types of bind calls. |
| // request: Object |
| // Object containing bind arguments. This object is converted to |
| // a dojo.io.Request object, and that request object is the return |
| // value for this method. |
| if(!(request instanceof dojo.io.Request)){ |
| try{ |
| request = new dojo.io.Request(request); |
| }catch(e){ dojo.debug(e); } |
| } |
| |
| // if the request asks for a particular implementation, use it |
| var tsName = ""; |
| if(request["transport"]){ |
| tsName = request["transport"]; |
| if(!this[tsName]){ |
| dojo.io.sendBindError(request, "No dojo.io.bind() transport with name '" |
| + request["transport"] + "'."); |
| return request; //dojo.io.Request |
| } |
| if(!this[tsName].canHandle(request)){ |
| dojo.io.sendBindError(request, "dojo.io.bind() transport with name '" |
| + request["transport"] + "' cannot handle this type of request."); |
| return request; //dojo.io.Request |
| } |
| }else{ |
| // otherwise we do our best to auto-detect what available transports |
| // will handle |
| for(var x=0; x<dojo.io.transports.length; x++){ |
| var tmp = dojo.io.transports[x]; |
| if((this[tmp])&&(this[tmp].canHandle(request))){ |
| tsName = tmp; |
| break; |
| } |
| } |
| if(tsName == ""){ |
| dojo.io.sendBindError(request, "None of the loaded transports for dojo.io.bind()" |
| + " can handle the request."); |
| return request; //dojo.io.Request |
| } |
| } |
| this[tsName].bind(request); |
| request.bindSuccess = true; |
| return request; //dojo.io.Request |
| } |
| |
| dojo.io.sendBindError = function(/* Object */request, /* String */message){ |
| // summary: |
| // Used internally by dojo.io.bind() to return/raise a bind error. |
| |
| //Need to be careful since not all hostenvs support setTimeout. |
| if((typeof request.error == "function" || typeof request.handle == "function") |
| && (typeof setTimeout == "function" || typeof setTimeout == "object")){ |
| var errorObject = new dojo.io.Error(message); |
| setTimeout(function(){ |
| request[(typeof request.error == "function") ? "error" : "handle"]("error", errorObject, null, request); |
| }, 50); |
| }else{ |
| dojo.raise(message); |
| } |
| } |
| |
| dojo.io.queueBind = function(/*dojo.io.Request or Object*/request){ |
| // summary: |
| // queueBind will use dojo.io.bind() but guarantee that only one bind |
| // call is handled at a time. |
| // description: |
| // If queueBind is called while a bind call |
| // is in process, it will queue up the other calls to bind and call them |
| // in order as bind calls complete. |
| // request: Object |
| // Same sort of request object as used for dojo.io.bind(). |
| if(!(request instanceof dojo.io.Request)){ |
| try{ |
| request = new dojo.io.Request(request); |
| }catch(e){ dojo.debug(e); } |
| } |
| |
| // make sure we get called if/when we get a response |
| var oldLoad = request.load; |
| request.load = function(){ |
| dojo.io._queueBindInFlight = false; |
| var ret = oldLoad.apply(this, arguments); |
| dojo.io._dispatchNextQueueBind(); |
| return ret; |
| } |
| |
| var oldErr = request.error; |
| request.error = function(){ |
| dojo.io._queueBindInFlight = false; |
| var ret = oldErr.apply(this, arguments); |
| dojo.io._dispatchNextQueueBind(); |
| return ret; |
| } |
| |
| dojo.io._bindQueue.push(request); |
| dojo.io._dispatchNextQueueBind(); |
| return request; //dojo.io.Request |
| } |
| |
| dojo.io._dispatchNextQueueBind = function(){ |
| // summary: |
| // Private method used by dojo.io.queueBind(). |
| if(!dojo.io._queueBindInFlight){ |
| dojo.io._queueBindInFlight = true; |
| if(dojo.io._bindQueue.length > 0){ |
| dojo.io.bind(dojo.io._bindQueue.shift()); |
| }else{ |
| dojo.io._queueBindInFlight = false; |
| } |
| } |
| } |
| dojo.io._bindQueue = []; |
| dojo.io._queueBindInFlight = false; |
| |
| dojo.io.argsFromMap = function(/*Object*/map, /*String?*/encoding, /*String?*/last){ |
| // summary: |
| // Converts name/values pairs in the map object to an URL-encoded string |
| // with format of name1=value1&name2=value2... |
| // map: Object |
| // Object that has the contains the names and values. |
| // encoding: String? |
| // String to specify how to encode the name and value. If the encoding string |
| // contains "utf" (case-insensitive), then encodeURIComponent is used. Otherwise |
| // dojo.string.encodeAscii is used. |
| // last: String? |
| // The last parameter in the list. Helps with final string formatting? |
| var enc = /utf/i.test(encoding||"") ? encodeURIComponent : dojo.string.encodeAscii; |
| var mapped = []; |
| var control = new Object(); |
| for(var name in map){ |
| var domap = function(elt){ |
| var val = enc(name)+"="+enc(elt); |
| mapped[(last == name) ? "push" : "unshift"](val); |
| } |
| if(!control[name]){ |
| var value = map[name]; |
| // FIXME: should be isArrayLike? |
| if (dojo.lang.isArray(value)){ |
| dojo.lang.forEach(value, domap); |
| }else{ |
| domap(value); |
| } |
| } |
| } |
| return mapped.join("&"); //String |
| } |
| |
| dojo.io.setIFrameSrc = function(/*DOMNode*/ iframe, /*String*/ src, /*Boolean*/ replace){ |
| //summary: |
| // Sets the URL that is loaded in an IFrame. The replace parameter indicates whether |
| // location.replace() should be used when changing the location of the iframe. |
| try{ |
| var r = dojo.render.html; |
| // dojo.debug(iframe); |
| if(!replace){ |
| if(r.safari){ |
| iframe.location = src; |
| }else{ |
| frames[iframe.name].location = src; |
| } |
| }else{ |
| // Fun with DOM 0 incompatibilities! |
| var idoc; |
| if(r.ie){ |
| idoc = iframe.contentWindow.document; |
| }else if(r.safari){ |
| idoc = iframe.document; |
| }else{ // if(r.moz){ |
| idoc = iframe.contentWindow; |
| } |
| |
| //For Safari (at least 2.0.3) and Opera, if the iframe |
| //has just been created but it doesn't have content |
| //yet, then iframe.document may be null. In that case, |
| //use iframe.location and return. |
| if(!idoc){ |
| iframe.location = src; |
| return; |
| }else{ |
| idoc.location.replace(src); |
| } |
| } |
| }catch(e){ |
| dojo.debug(e); |
| dojo.debug("setIFrameSrc: "+e); |
| } |
| } |
| |
| /* |
| dojo.io.sampleTranport = new function(){ |
| this.canHandle = function(kwArgs){ |
| // canHandle just tells dojo.io.bind() if this is a good transport to |
| // use for the particular type of request. |
| if( |
| ( |
| (kwArgs["mimetype"] == "text/plain") || |
| (kwArgs["mimetype"] == "text/html") || |
| (kwArgs["mimetype"] == "text/javascript") |
| )&&( |
| (kwArgs["method"] == "get") || |
| ( (kwArgs["method"] == "post") && (!kwArgs["formNode"]) ) |
| ) |
| ){ |
| return true; |
| } |
| |
| return false; |
| } |
| |
| this.bind = function(kwArgs){ |
| var hdlrObj = {}; |
| |
| // set up a handler object |
| for(var x=0; x<dojo.io.hdlrFuncNames.length; x++){ |
| var fn = dojo.io.hdlrFuncNames[x]; |
| if(typeof kwArgs.handler == "object"){ |
| if(typeof kwArgs.handler[fn] == "function"){ |
| hdlrObj[fn] = kwArgs.handler[fn]||kwArgs.handler["handle"]; |
| } |
| }else if(typeof kwArgs[fn] == "function"){ |
| hdlrObj[fn] = kwArgs[fn]; |
| }else{ |
| hdlrObj[fn] = kwArgs["handle"]||function(){}; |
| } |
| } |
| |
| // build a handler function that calls back to the handler obj |
| var hdlrFunc = function(evt){ |
| if(evt.type == "onload"){ |
| hdlrObj.load("load", evt.data, evt); |
| }else if(evt.type == "onerr"){ |
| var errObj = new dojo.io.Error("sampleTransport Error: "+evt.msg); |
| hdlrObj.error("error", errObj); |
| } |
| } |
| |
| // the sample transport would attach the hdlrFunc() when sending the |
| // request down the pipe at this point |
| var tgtURL = kwArgs.url+"?"+dojo.io.argsFromMap(kwArgs.content); |
| // sampleTransport.sendRequest(tgtURL, hdlrFunc); |
| } |
| |
| dojo.io.transports.addTransport("sampleTranport"); |
| } |
| */ |
| |
| dojo.provide("dojo.lang.array"); |
| |
| |
| |
| // FIXME: Is this worthless since you can do: if(name in obj) |
| // is this the right place for this? |
| |
| dojo.lang.mixin(dojo.lang, { |
| has: function(/*Object*/obj, /*String*/name){ |
| // summary: is there a property with the passed name in obj? |
| try{ |
| return typeof obj[name] != "undefined"; // Boolean |
| }catch(e){ return false; } // Boolean |
| }, |
| |
| isEmpty: function(/*Object*/obj){ |
| // summary: |
| // can be used to determine if the passed object is "empty". In |
| // the case of array-like objects, the length, property is |
| // examined, but for other types of objects iteration is used to |
| // examine the iterable "surface area" to determine if any |
| // non-prototypal properties have been assigned. This iteration is |
| // prototype-extension safe. |
| if(dojo.lang.isObject(obj)){ |
| var tmp = {}; |
| var count = 0; |
| for(var x in obj){ |
| if(obj[x] && (!tmp[x])){ |
| count++; |
| break; |
| } |
| } |
| return count == 0; // boolean |
| }else if(dojo.lang.isArrayLike(obj) || dojo.lang.isString(obj)){ |
| return obj.length == 0; // boolean |
| } |
| }, |
| |
| map: function(/*Array*/arr, /*Object|Function*/obj, /*Function?*/unary_func){ |
| // summary: |
| // returns a new array constituded from the return values of |
| // passing each element of arr into unary_func. The obj parameter |
| // may be passed to enable the passed function to be called in |
| // that scope. In environments that support JavaScript 1.6, this |
| // function is a passthrough to the built-in map() function |
| // provided by Array instances. For details on this, see: |
| // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:map |
| // examples: |
| // dojo.lang.map([1, 2, 3, 4], function(item){ return item+1 }); |
| // // returns [2, 3, 4, 5] |
| var isString = dojo.lang.isString(arr); |
| if(isString){ |
| // arr: String |
| arr = arr.split(""); |
| } |
| if(dojo.lang.isFunction(obj)&&(!unary_func)){ |
| unary_func = obj; |
| obj = dj_global; |
| }else if(dojo.lang.isFunction(obj) && unary_func){ |
| // ff 1.5 compat |
| var tmpObj = obj; |
| obj = unary_func; |
| unary_func = tmpObj; |
| } |
| if(Array.map){ |
| var outArr = Array.map(arr, unary_func, obj); |
| }else{ |
| var outArr = []; |
| for(var i=0;i<arr.length;++i){ |
| outArr.push(unary_func.call(obj, arr[i])); |
| } |
| } |
| if(isString) { |
| return outArr.join(""); // String |
| } else { |
| return outArr; // Array |
| } |
| }, |
| |
| reduce: function(/*Array*/arr, initialValue, /*Object|Function*/obj, /*Function*/binary_func){ |
| // summary: |
| // similar to Python's builtin reduce() function. The result of |
| // the previous computation is passed as the first argument to |
| // binary_func along with the next value from arr. The result of |
| // this call is used along with the subsequent value from arr, and |
| // this continues until arr is exhausted. The return value is the |
| // last result. The "obj" and "initialValue" parameters may be |
| // safely omitted and the order of obj and binary_func may be |
| // reversed. The default order of the obj and binary_func argument |
| // will probably be reversed in a future release, and this call |
| // order is supported today. |
| // examples: |
| // dojo.lang.reduce([1, 2, 3, 4], function(last, next){ return last+next}); |
| // returns 10 |
| var reducedValue = initialValue; |
| if(arguments.length == 2){ |
| binary_func = initialValue; |
| reducedValue = arr[0]; |
| arr = arr.slice(1); |
| }else if(arguments.length == 3){ |
| if(dojo.lang.isFunction(obj)){ |
| binary_func = obj; |
| obj = null; |
| } |
| }else{ |
| // un-fsck the default order |
| // FIXME: |
| // could be wrong for some strange function object cases. Not |
| // sure how to test for them. |
| if(dojo.lang.isFunction(obj)){ |
| var tmp = binary_func; |
| binary_func = obj; |
| obj = tmp; |
| } |
| } |
| |
| var ob = obj || dj_global; |
| dojo.lang.map(arr, |
| function(val){ |
| reducedValue = binary_func.call(ob, reducedValue, val); |
| } |
| ); |
| return reducedValue; |
| }, |
| |
| forEach: function(/*Array*/anArray, /*Function*/callback, /*Object?*/thisObject){ |
| // summary: |
| // for every item in anArray, call callback with that item as its |
| // only parameter. Return values are ignored. This funciton |
| // corresponds (and wraps) the JavaScript 1.6 forEach method. For |
| // more details, see: |
| // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:forEach |
| if(dojo.lang.isString(anArray)){ |
| // anArray: String |
| anArray = anArray.split(""); |
| } |
| if(Array.forEach){ |
| Array.forEach(anArray, callback, thisObject); |
| }else{ |
| // FIXME: there are several ways of handilng thisObject. Is dj_global always the default context? |
| if(!thisObject){ |
| thisObject=dj_global; |
| } |
| for(var i=0,l=anArray.length; i<l; i++){ |
| callback.call(thisObject, anArray[i], i, anArray); |
| } |
| } |
| }, |
| |
| _everyOrSome: function(/*Boolean*/every, /*Array*/arr, /*Function*/callback, /*Object?*/thisObject){ |
| if(dojo.lang.isString(arr)){ |
| //arr: String |
| arr = arr.split(""); |
| } |
| if(Array.every){ |
| return Array[ every ? "every" : "some" ](arr, callback, thisObject); |
| }else{ |
| if(!thisObject){ |
| thisObject = dj_global; |
| } |
| for(var i=0,l=arr.length; i<l; i++){ |
| var result = callback.call(thisObject, arr[i], i, arr); |
| if(every && !result){ |
| return false; // Boolean |
| }else if((!every)&&(result)){ |
| return true; // Boolean |
| } |
| } |
| return Boolean(every); // Boolean |
| } |
| }, |
| |
| every: function(/*Array*/arr, /*Function*/callback, /*Object?*/thisObject){ |
| // summary: |
| // determines whether or not every item in the array satisfies the |
| // condition implemented by callback. thisObject may be used to |
| // scope the call to callback. The function signature is derived |
| // from the JavaScript 1.6 Array.every() function. More |
| // information on this can be found here: |
| // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every |
| // examples: |
| // dojo.lang.every([1, 2, 3, 4], function(item){ return item>1; }); |
| // // returns false |
| // dojo.lang.every([1, 2, 3, 4], function(item){ return item>0; }); |
| // // returns true |
| return this._everyOrSome(true, arr, callback, thisObject); // Boolean |
| }, |
| |
| some: function(/*Array*/arr, /*Function*/callback, /*Object?*/thisObject){ |
| // summary: |
| // determines whether or not any item in the array satisfies the |
| // condition implemented by callback. thisObject may be used to |
| // scope the call to callback. The function signature is derived |
| // from the JavaScript 1.6 Array.some() function. More |
| // information on this can be found here: |
| // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some |
| // examples: |
| // dojo.lang.some([1, 2, 3, 4], function(item){ return item>1; }); |
| // // returns true |
| // dojo.lang.some([1, 2, 3, 4], function(item){ return item<1; }); |
| // // returns false |
| return this._everyOrSome(false, arr, callback, thisObject); // Boolean |
| }, |
| |
| filter: function(/*Array*/arr, /*Function*/callback, /*Object?*/thisObject){ |
| // summary: |
| // returns a new Array with those items from arr that match the |
| // condition implemented by callback.thisObject may be used to |
| // scope the call to callback. The function signature is derived |
| // from the JavaScript 1.6 Array.filter() function, although |
| // special accomidation is made in our implementation for strings. |
| // More information on the JS 1.6 API can be found here: |
| // http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:filter |
| // examples: |
| // dojo.lang.some([1, 2, 3, 4], function(item){ return item>1; }); |
| // // returns [2, 3, 4] |
| var isString = dojo.lang.isString(arr); |
| if(isString){ /*arr: String*/arr = arr.split(""); } |
| var outArr; |
| if(Array.filter){ |
| outArr = Array.filter(arr, callback, thisObject); |
| }else{ |
| if(!thisObject){ |
| if(arguments.length >= 3){ dojo.raise("thisObject doesn't exist!"); } |
| thisObject = dj_global; |
| } |
| |
| outArr = []; |
| for(var i = 0; i < arr.length; i++){ |
| if(callback.call(thisObject, arr[i], i, arr)){ |
| outArr.push(arr[i]); |
| } |
| } |
| } |
| if(isString){ |
| return outArr.join(""); // String |
| } else { |
| return outArr; // Array |
| } |
| }, |
| |
| unnest: function(/* ... */){ |
| // summary: |
| // Creates a 1-D array out of all the arguments passed, |
| // unravelling any array-like objects in the process |
| // usage: |
| // unnest(1, 2, 3) ==> [1, 2, 3] |
| // unnest(1, [2, [3], [[[4]]]]) ==> [1, 2, 3, 4] |
| |
| var out = []; |
| for(var i = 0; i < arguments.length; i++){ |
| if(dojo.lang.isArrayLike(arguments[i])){ |
| var add = dojo.lang.unnest.apply(this, arguments[i]); |
| out = out.concat(add); |
| }else{ |
| out.push(arguments[i]); |
| } |
| } |
| return out; // Array |
| }, |
| |
| toArray: function(/*Object*/arrayLike, /*Number*/startOffset){ |
| // summary: |
| // Converts an array-like object (i.e. arguments, DOMCollection) |
| // to an array. Returns a new Array object. |
| var array = []; |
| for(var i = startOffset||0; i < arrayLike.length; i++){ |
| array.push(arrayLike[i]); |
| } |
| return array; // Array |
| } |
| }); |
| |
| dojo.provide("dojo.lang.func"); |
| |
| |
| dojo.lang.hitch = function(/*Object*/thisObject, /*Function|String*/method /*, ...*/){ |
| // summary: |
| // Returns a function that will only ever execute in the a given scope |
| // (thisObject). This allows for easy use of object member functions |
| // in callbacks and other places in which the "this" keyword may |
| // otherwise not reference the expected scope. Any number of default |
| // positional arguments may be passed as parameters beyond "method". |
| // Each of these values will be used to "placehold" (similar to curry) |
| // for the hitched function. Note that the order of arguments may be |
| // reversed in a future version. |
| // thisObject: the scope to run the method in |
| // method: |
| // a function to be "bound" to thisObject or the name of the method in |
| // thisObject to be used as the basis for the binding |
| // usage: |
| // dojo.lang.hitch(foo, "bar")(); // runs foo.bar() in the scope of foo |
| // dojo.lang.hitch(foo, myFunction); // returns a function that runs myFunction in the scope of foo |
| |
| var args = []; |
| for(var x=2; x<arguments.length; x++){ |
| args.push(arguments[x]); |
| } |
| var fcn = (dojo.lang.isString(method) ? thisObject[method] : method) || function(){}; |
| return function(){ |
| var ta = args.concat([]); // make a copy |
| for(var x=0; x<arguments.length; x++){ |
| ta.push(arguments[x]); |
| } |
| return fcn.apply(thisObject, ta); // Function |
| // return fcn.apply(thisObject, arguments); // Function |
| }; |
| } |
| |
| dojo.lang.anonCtr = 0; |
| dojo.lang.anon = {}; |
| |
| dojo.lang.nameAnonFunc = function(/*Function*/anonFuncPtr, /*Object*/thisObj, /*Boolean*/searchForNames){ |
| // summary: |
| // Creates a reference to anonFuncPtr in thisObj with a completely |
| // unique name. The new name is returned as a String. If |
| // searchForNames is true, an effort will be made to locate an |
| // existing reference to anonFuncPtr in thisObj, and if one is found, |
| // the existing name will be returned instead. The default is for |
| // searchForNames to be false. |
| var nso = (thisObj|| dojo.lang.anon); |
| if( (searchForNames) || |
| ((dj_global["djConfig"])&&(djConfig["slowAnonFuncLookups"] == true)) ){ |
| for(var x in nso){ |
| try{ |
| if(nso[x] === anonFuncPtr){ |
| return x; |
| } |
| }catch(e){} // window.external fails in IE embedded in Eclipse (Eclipse bug #151165) |
| } |
| } |
| var ret = "__"+dojo.lang.anonCtr++; |
| while(typeof nso[ret] != "undefined"){ |
| ret = "__"+dojo.lang.anonCtr++; |
| } |
| nso[ret] = anonFuncPtr; |
| return ret; // String |
| } |
| |
| dojo.lang.forward = function(funcName){ |
| // summary: |
| // Returns a function that forwards a method call to |
| // this.funcName(...). Unlike dojo.lang.hitch(), the "this" scope is |
| // not fixed on a single object. Ported from MochiKit. |
| return function(){ |
| return this[funcName].apply(this, arguments); |
| }; // Function |
| } |
| |
| dojo.lang.curry = function(thisObj, func /* args ... */){ |
| // summary: |
| // similar to the curry() method found in many functional programming |
| // environments, this function returns an "argument accumulator" |
| // function, bound to a particular scope, and "primed" with a variable |
| // number of arguments. The curry method is unique in that it returns |
| // a function that may return other "partial" function which can be |
| // called repeatedly. New functions are returned until the arity of |
| // the original function is reached, at which point the underlying |
| // function (func) is called in the scope thisObj with all of the |
| // accumulated arguments (plus any extras) in positional order. |
| // examples: |
| // assuming a function defined like this: |
| // var foo = { |
| // bar: function(arg1, arg2, arg3){ |
| // dojo.debug.apply(dojo, arguments); |
| // } |
| // }; |
| // |
| // dojo.lang.curry() can be used most simply in this way: |
| // |
| // tmp = dojo.lang.curry(foo, foo.bar, "arg one", "thinger"); |
| // tmp("blah", "this is superfluous"); |
| // // debugs: "arg one thinger blah this is superfluous" |
| // tmp("blah"); |
| // // debugs: "arg one thinger blah" |
| // tmp(); |
| // // returns a function exactly like tmp that expects one argument |
| // |
| // other intermittent functions could be created until the 3 |
| // positional arguments are filled: |
| // |
| // tmp = dojo.lang.curry(foo, foo.bar, "arg one"); |
| // tmp2 = tmp("arg two"); |
| // tmp2("blah blah"); |
| // // debugs: "arg one arg two blah blah" |
| // tmp2("oy"); |
| // // debugs: "arg one arg two oy" |
| // |
| // curry() can also be used to call the function if enough arguments |
| // are passed in the initial invocation: |
| // |
| // dojo.lang.curry(foo, foo.bar, "one", "two", "three", "four"); |
| // // debugs: "one two three four" |
| // dojo.lang.curry(foo, foo.bar, "one", "two", "three"); |
| // // debugs: "one two three" |
| |
| |
| // FIXME: the order of func and thisObj should be changed!!! |
| var outerArgs = []; |
| thisObj = thisObj||dj_global; |
| if(dojo.lang.isString(func)){ |
| func = thisObj[func]; |
| } |
| for(var x=2; x<arguments.length; x++){ |
| outerArgs.push(arguments[x]); |
| } |
| // since the event system replaces the original function with a new |
| // join-point runner with an arity of 0, we check to see if it's left us |
| // any clues about the original arity in lieu of the function's actual |
| // length property |
| var ecount = (func["__preJoinArity"]||func.length) - outerArgs.length; |
| // borrowed from svend tofte |
| function gather(nextArgs, innerArgs, expected){ |
| var texpected = expected; |
| var totalArgs = innerArgs.slice(0); // copy |
| for(var x=0; x<nextArgs.length; x++){ |
| totalArgs.push(nextArgs[x]); |
| } |
| // check the list of provided nextArgs to see if it, plus the |
| // number of innerArgs already supplied, meets the total |
| // expected. |
| expected = expected-nextArgs.length; |
| if(expected<=0){ |
| var res = func.apply(thisObj, totalArgs); |
| expected = texpected; |
| return res; |
| }else{ |
| return function(){ |
| return gather(arguments,// check to see if we've been run |
| // with enough args |
| totalArgs, // a copy |
| expected); // how many more do we need to run?; |
| }; |
| } |
| } |
| return gather([], outerArgs, ecount); |
| } |
| |
| dojo.lang.curryArguments = function(/*Object*/thisObj, /*Function*/func, /*Array*/args, /*Integer, optional*/offset){ |
| // summary: |
| // similar to dojo.lang.curry(), except that a list of arguments to |
| // start the curry with may be provided as an array instead of as |
| // positional arguments. An offset may be specified from the 0 index |
| // to skip some elements in args. |
| var targs = []; |
| var x = offset||0; |
| for(x=offset; x<args.length; x++){ |
| targs.push(args[x]); // ensure that it's an arr |
| } |
| return dojo.lang.curry.apply(dojo.lang, [thisObj, func].concat(targs)); |
| } |
| |
| dojo.lang.tryThese = function(/*...*/){ |
| // summary: |
| // executes each function argument in turn, returning the return value |
| // from the first one which does not throw an exception in execution. |
| // Any number of functions may be passed. |
| for(var x=0; x<arguments.length; x++){ |
| try{ |
| if(typeof arguments[x] == "function"){ |
| var ret = (arguments[x]()); |
| if(ret){ |
| return ret; |
| } |
| } |
| }catch(e){ |
| dojo.debug(e); |
| } |
| } |
| } |
| |
| dojo.lang.delayThese = function(/*Array*/farr, /*Function, optional*/cb, /*Integer*/delay, /*Function, optional*/onend){ |
| // summary: |
| // executes a series of functions contained in farr, but spaces out |
| // calls to each function by the millisecond delay provided. If cb is |
| // provided, it will be called directly after each item in farr is |
| // called and if onend is passed, it will be called when all items |
| // have completed executing. |
| |
| /** |
| * alternate: (array funcArray, function callback, function onend) |
| * alternate: (array funcArray, function callback) |
| * alternate: (array funcArray) |
| */ |
| if(!farr.length){ |
| if(typeof onend == "function"){ |
| onend(); |
| } |
| return; |
| } |
| if((typeof delay == "undefined")&&(typeof cb == "number")){ |
| delay = cb; |
| cb = function(){}; |
| }else if(!cb){ |
| cb = function(){}; |
| if(!delay){ delay = 0; } |
| } |
| setTimeout(function(){ |
| (farr.shift())(); |
| cb(); |
| dojo.lang.delayThese(farr, cb, delay, onend); |
| }, delay); |
| } |
| |
| dojo.provide("dojo.string.extras"); |
| |
| |
| |
| |
| |
| //TODO: should we use ${} substitution syntax instead, like widgets do? |
| dojo.string.substituteParams = function(/*string*/template, /* object - optional or ... */hash){ |
| // summary: |
| // Performs parameterized substitutions on a string. Throws an exception if any parameter is unmatched. |
| // |
| // description: |
| // For example, |
| // dojo.string.substituteParams("File '%{0}' is not found in directory '%{1}'.","foo.html","/temp"); |
| // returns |
| // "File 'foo.html' is not found in directory '/temp'." |
| // |
| // template: the original string template with %{values} to be replaced |
| // hash: name/value pairs (type object) to provide substitutions. Alternatively, substitutions may be |
| // included as arguments 1..n to this function, corresponding to template parameters 0..n-1 |
| |
| var map = (typeof hash == 'object') ? hash : dojo.lang.toArray(arguments, 1); |
| |
| return template.replace(/\%\{(\w+)\}/g, function(match, key){ |
| if(typeof(map[key]) != "undefined" && map[key] != null){ |
| return map[key]; |
| } |
| dojo.raise("Substitution not found: " + key); |
| }); // string |
| }; |
| |
| dojo.string.capitalize = function(/*string*/str){ |
| // summary: |
| // Uppercases the first letter of each word |
| |
| if(!dojo.lang.isString(str)){ return ""; } |
| if(arguments.length == 0){ str = this; } |
| |
| var words = str.split(' '); |
| for(var i=0; i<words.length; i++){ |
| words[i] = words[i].charAt(0).toUpperCase() + words[i].substring(1); |
| } |
| return words.join(" "); // string |
| } |
| |
| dojo.string.isBlank = function(/*string*/str){ |
| // summary: |
| // Return true if the entire string is whitespace characters |
| |
| if(!dojo.lang.isString(str)){ return true; } |
| return (dojo.string.trim(str).length == 0); // boolean |
| } |
| |
| //FIXME: not sure exactly what encodeAscii is trying to do, or if it's working right |
| dojo.string.encodeAscii = function(/*string*/str){ |
| if(!dojo.lang.isString(str)){ return str; } // unknown |
| var ret = ""; |
| var value = escape(str); |
| var match, re = /%u([0-9A-F]{4})/i; |
| while((match = value.match(re))){ |
| var num = Number("0x"+match[1]); |
| var newVal = escape("&#" + num + ";"); |
| ret += value.substring(0, match.index) + newVal; |
| value = value.substring(match.index+match[0].length); |
| } |
| ret += value.replace(/\+/g, "%2B"); |
| return ret; // string |
| } |
| |
| dojo.string.escape = function(/*string*/type, /*string*/str){ |
| // summary: |
| // Adds escape sequences for special characters according to the convention of 'type' |
| // |
| // type: one of xml|html|xhtml|sql|regexp|regex|javascript|jscript|js|ascii |
| // str: the string to be escaped |
| |
| var args = dojo.lang.toArray(arguments, 1); |
| switch(type.toLowerCase()){ |
| case "xml": |
| case "html": |
| case "xhtml": |
| return dojo.string.escapeXml.apply(this, args); // string |
| case "sql": |
| return dojo.string.escapeSql.apply(this, args); // string |
| case "regexp": |
| case "regex": |
| return dojo.string.escapeRegExp.apply(this, args); // string |
| case "javascript": |
| case "jscript": |
| case "js": |
| return dojo.string.escapeJavaScript.apply(this, args); // string |
| case "ascii": |
| // so it's encode, but it seems useful |
| return dojo.string.encodeAscii.apply(this, args); // string |
| default: |
| return str; // string |
| } |
| } |
| |
| dojo.string.escapeXml = function(/*string*/str, /*boolean*/noSingleQuotes){ |
| //summary: |
| // Adds escape sequences for special characters in XML: &<>"' |
| // Optionally skips escapes for single quotes |
| |
| str = str.replace(/&/gm, "&").replace(/</gm, "<") |
| .replace(/>/gm, ">").replace(/"/gm, """); |
| if(!noSingleQuotes){ str = str.replace(/'/gm, "'"); } |
| return str; // string |
| } |
| |
| dojo.string.escapeSql = function(/*string*/str){ |
| //summary: |
| // Adds escape sequences for single quotes in SQL expressions |
| |
| return str.replace(/'/gm, "''"); //string |
| } |
| |
| dojo.string.escapeRegExp = function(/*string*/str){ |
| //summary: |
| // Adds escape sequences for special characters in regular expressions |
| |
| return str.replace(/\\/gm, "\\\\").replace(/([\f\b\n\t\r[\^$|?*+(){}])/gm, "\\$1"); // string |
| } |
| |
| //FIXME: should this one also escape backslash? |
| dojo.string.escapeJavaScript = function(/*string*/str){ |
| //summary: |
| // Adds escape sequences for single and double quotes as well |
| // as non-visible characters in JavaScript string literal expressions |
| |
| return str.replace(/(["'\f\b\n\t\r])/gm, "\\$1"); // string |
| } |
| |
| //FIXME: looks a lot like escapeJavaScript, just adds quotes? deprecate one? |
| dojo.string.escapeString = function(/*string*/str){ |
| //summary: |
| // Adds escape sequences for non-visual characters, double quote and backslash |
| // and surrounds with double quotes to form a valid string literal. |
| return ('"' + str.replace(/(["\\])/g, '\\$1') + '"' |
| ).replace(/[\f]/g, "\\f" |
| ).replace(/[\b]/g, "\\b" |
| ).replace(/[\n]/g, "\\n" |
| ).replace(/[\t]/g, "\\t" |
| ).replace(/[\r]/g, "\\r"); // string |
| } |
| |
| // TODO: make an HTML version |
| dojo.string.summary = function(/*string*/str, /*number*/len){ |
| // summary: |
| // Truncates 'str' after 'len' characters and appends periods as necessary so that it ends with "..." |
| |
| if(!len || str.length <= len){ |
| return str; // string |
| } |
| |
| return str.substring(0, len).replace(/\.+$/, "") + "..."; // string |
| } |
| |
| dojo.string.endsWith = function(/*string*/str, /*string*/end, /*boolean*/ignoreCase){ |
| // summary: |
| // Returns true if 'str' ends with 'end' |
| |
| if(ignoreCase){ |
| str = str.toLowerCase(); |
| end = end.toLowerCase(); |
| } |
| if((str.length - end.length) < 0){ |
| return false; // boolean |
| } |
| return str.lastIndexOf(end) == str.length - end.length; // boolean |
| } |
| |
| dojo.string.endsWithAny = function(/*string*/str /* , ... */){ |
| // summary: |
| // Returns true if 'str' ends with any of the arguments[2 -> n] |
| |
| for(var i = 1; i < arguments.length; i++) { |
| if(dojo.string.endsWith(str, arguments[i])) { |
| return true; // boolean |
| } |
| } |
| return false; // boolean |
| } |
| |
| dojo.string.startsWith = function(/*string*/str, /*string*/start, /*boolean*/ignoreCase){ |
| // summary: |
| // Returns true if 'str' starts with 'start' |
| |
| if(ignoreCase) { |
| str = str.toLowerCase(); |
| start = start.toLowerCase(); |
| } |
| return str.indexOf(start) == 0; // boolean |
| } |
| |
| dojo.string.startsWithAny = function(/*string*/str /* , ... */){ |
| // summary: |
| // Returns true if 'str' starts with any of the arguments[2 -> n] |
| |
| for(var i = 1; i < arguments.length; i++) { |
| if(dojo.string.startsWith(str, arguments[i])) { |
| return true; // boolean |
| } |
| } |
| return false; // boolean |
| } |
| |
| dojo.string.has = function(/*string*/str /* , ... */) { |
| // summary: |
| // Returns true if 'str' contains any of the arguments 2 -> n |
| |
| for(var i = 1; i < arguments.length; i++) { |
| if(str.indexOf(arguments[i]) > -1){ |
| return true; // boolean |
| } |
| } |
| return false; // boolean |
| } |
| |
| dojo.string.normalizeNewlines = function(/*string*/text, /*string? (\n or \r)*/newlineChar){ |
| // summary: |
| // Changes occurences of CR and LF in text to CRLF, or if newlineChar is provided as '\n' or '\r', |
| // substitutes newlineChar for occurrences of CR/LF and CRLF |
| |
| if (newlineChar == "\n"){ |
| text = text.replace(/\r\n/g, "\n"); |
| text = text.replace(/\r/g, "\n"); |
| } else if (newlineChar == "\r"){ |
| text = text.replace(/\r\n/g, "\r"); |
| text = text.replace(/\n/g, "\r"); |
| }else{ |
| text = text.replace(/([^\r])\n/g, "$1\r\n").replace(/\r([^\n])/g, "\r\n$1"); |
| } |
| return text; // string |
| } |
| |
| dojo.string.splitEscaped = function(/*string*/str, /*string of length=1*/charac){ |
| // summary: |
| // Splits 'str' into an array separated by 'charac', but skips characters escaped with a backslash |
| |
| var components = []; |
| for (var i = 0, prevcomma = 0; i < str.length; i++){ |
| if (str.charAt(i) == '\\'){ i++; continue; } |
| if (str.charAt(i) == charac){ |
| components.push(str.substring(prevcomma, i)); |
| prevcomma = i + 1; |
| } |
| } |
| components.push(str.substr(prevcomma)); |
| return components; // array |
| } |
| |
| dojo.provide("dojo.dom"); |
| |
| dojo.dom.ELEMENT_NODE = 1; |
| dojo.dom.ATTRIBUTE_NODE = 2; |
| dojo.dom.TEXT_NODE = 3; |
| dojo.dom.CDATA_SECTION_NODE = 4; |
| dojo.dom.ENTITY_REFERENCE_NODE = 5; |
| dojo.dom.ENTITY_NODE = 6; |
| dojo.dom.PROCESSING_INSTRUCTION_NODE = 7; |
| dojo.dom.COMMENT_NODE = 8; |
| dojo.dom.DOCUMENT_NODE = 9; |
| dojo.dom.DOCUMENT_TYPE_NODE = 10; |
| dojo.dom.DOCUMENT_FRAGMENT_NODE = 11; |
| dojo.dom.NOTATION_NODE = 12; |
| |
| dojo.dom.dojoml = "http://www.dojotoolkit.org/2004/dojoml"; |
| |
| /** |
| * comprehensive list of XML namespaces |
| **/ |
| dojo.dom.xmlns = { |
| // summary |
| // aliases for various common XML namespaces |
| svg : "http://www.w3.org/2000/svg", |
| smil : "http://www.w3.org/2001/SMIL20/", |
| mml : "http://www.w3.org/1998/Math/MathML", |
| cml : "http://www.xml-cml.org", |
| xlink : "http://www.w3.org/1999/xlink", |
| xhtml : "http://www.w3.org/1999/xhtml", |
| xul : "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul", |
| xbl : "http://www.mozilla.org/xbl", |
| fo : "http://www.w3.org/1999/XSL/Format", |
| xsl : "http://www.w3.org/1999/XSL/Transform", |
| xslt : "http://www.w3.org/1999/XSL/Transform", |
| xi : "http://www.w3.org/2001/XInclude", |
| xforms : "http://www.w3.org/2002/01/xforms", |
| saxon : "http://icl.com/saxon", |
| xalan : "http://xml.apache.org/xslt", |
| xsd : "http://www.w3.org/2001/XMLSchema", |
| dt: "http://www.w3.org/2001/XMLSchema-datatypes", |
| xsi : "http://www.w3.org/2001/XMLSchema-instance", |
| rdf : "http://www.w3.org/1999/02/22-rdf-syntax-ns#", |
| rdfs : "http://www.w3.org/2000/01/rdf-schema#", |
| dc : "http://purl.org/dc/elements/1.1/", |
| dcq: "http://purl.org/dc/qualifiers/1.0", |
| "soap-env" : "http://schemas.xmlsoap.org/soap/envelope/", |
| wsdl : "http://schemas.xmlsoap.org/wsdl/", |
| AdobeExtensions : "http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/" |
| }; |
| |
| dojo.dom.isNode = function(/* object */wh){ |
| // summary: |
| // checks to see if wh is actually a node. |
| if(typeof Element == "function") { |
| try { |
| return wh instanceof Element; // boolean |
| } catch(e) {} |
| } else { |
| // best-guess |
| return wh && !isNaN(wh.nodeType); // boolean |
| } |
| } |
| |
| dojo.dom.getUniqueId = function(){ |
| // summary: |
| // returns a unique string for use with any DOM element |
| var _document = dojo.doc(); |
| do { |
| var id = "dj_unique_" + (++arguments.callee._idIncrement); |
| }while(_document.getElementById(id)); |
| return id; // string |
| } |
| dojo.dom.getUniqueId._idIncrement = 0; |
| |
| dojo.dom.firstElement = dojo.dom.getFirstChildElement = function(/* Element */parentNode, /* string? */tagName){ |
| // summary: |
| // returns the first child element matching tagName |
| var node = parentNode.firstChild; |
| while(node && node.nodeType != dojo.dom.ELEMENT_NODE){ |
| node = node.nextSibling; |
| } |
| if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) { |
| node = dojo.dom.nextElement(node, tagName); |
| } |
| return node; // Element |
| } |
| |
| dojo.dom.lastElement = dojo.dom.getLastChildElement = function(/* Element */parentNode, /* string? */tagName){ |
| // summary: |
| // returns the last child element matching tagName |
| var node = parentNode.lastChild; |
| while(node && node.nodeType != dojo.dom.ELEMENT_NODE) { |
| node = node.previousSibling; |
| } |
| if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) { |
| node = dojo.dom.prevElement(node, tagName); |
| } |
| return node; // Element |
| } |
| |
| dojo.dom.nextElement = dojo.dom.getNextSiblingElement = function(/* Node */node, /* string? */tagName){ |
| // summary: |
| // returns the next sibling element matching tagName |
| if(!node) { return null; } |
| do { |
| node = node.nextSibling; |
| } while(node && node.nodeType != dojo.dom.ELEMENT_NODE); |
| |
| if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) { |
| return dojo.dom.nextElement(node, tagName); |
| } |
| return node; // Element |
| } |
| |
| dojo.dom.prevElement = dojo.dom.getPreviousSiblingElement = function(/* Node */node, /* string? */tagName){ |
| // summary: |
| // returns the previous sibling element matching tagName |
| if(!node) { return null; } |
| if(tagName) { tagName = tagName.toLowerCase(); } |
| do { |
| node = node.previousSibling; |
| } while(node && node.nodeType != dojo.dom.ELEMENT_NODE); |
| |
| if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) { |
| return dojo.dom.prevElement(node, tagName); |
| } |
| return node; // Element |
| } |
| |
| // TODO: hmph |
| /*this.forEachChildTag = function(node, unaryFunc) { |
| var child = this.getFirstChildTag(node); |
| while(child) { |
| if(unaryFunc(child) == "break") { break; } |
| child = this.getNextSiblingTag(child); |
| } |
| }*/ |
| |
| dojo.dom.moveChildren = function(/*Element*/srcNode, /*Element*/destNode, /*boolean?*/trim){ |
| // summary: |
| // Moves children from srcNode to destNode and returns the count of |
| // children moved; will trim off text nodes if trim == true |
| var count = 0; |
| if(trim) { |
| while(srcNode.hasChildNodes() && |
| srcNode.firstChild.nodeType == dojo.dom.TEXT_NODE) { |
| srcNode.removeChild(srcNode.firstChild); |
| } |
| while(srcNode.hasChildNodes() && |
| srcNode.lastChild.nodeType == dojo.dom.TEXT_NODE) { |
| srcNode.removeChild(srcNode.lastChild); |
| } |
| } |
| while(srcNode.hasChildNodes()){ |
| destNode.appendChild(srcNode.firstChild); |
| count++; |
| } |
| return count; // number |
| } |
| |
| dojo.dom.copyChildren = function(/*Element*/srcNode, /*Element*/destNode, /*boolean?*/trim){ |
| // summary: |
| // Copies children from srcNde to destNode and returns the count of |
| // children copied; will trim off text nodes if trim == true |
| var clonedNode = srcNode.cloneNode(true); |
| return this.moveChildren(clonedNode, destNode, trim); // number |
| } |
| |
| dojo.dom.replaceChildren = function(/*Element*/node, /*Node*/newChild){ |
| // summary: |
| // Removes all children of node and appends newChild. All the existing |
| // children will be destroyed. |
| // FIXME: what if newChild is an array-like object? |
| var nodes = []; |
| if(dojo.render.html.ie){ |
| for(var i=0;i<node.childNodes.length;i++){ |
| nodes.push(node.childNodes[i]); |
| } |
| } |
| dojo.dom.removeChildren(node); |
| node.appendChild(newChild); |
| for(var i=0;i<nodes.length;i++){ |
| dojo.dom.destroyNode(nodes[i]); |
| } |
| } |
| |
| dojo.dom.removeChildren = function(/*Element*/node){ |
| // summary: |
| // removes all children from node and returns the count of children removed. |
| // The children nodes are not destroyed. Be sure to call destroyNode on them |
| // after they are not used anymore. |
| var count = node.childNodes.length; |
| while(node.hasChildNodes()){ dojo.dom.removeNode(node.firstChild); } |
| return count; // int |
| } |
| |
| dojo.dom.replaceNode = function(/*Element*/node, /*Element*/newNode){ |
| // summary: |
| // replaces node with newNode and returns a reference to the removed node. |
| // To prevent IE memory leak, call destroyNode on the returned node when |
| // it is no longer needed. |
| return node.parentNode.replaceChild(newNode, node); // Node |
| } |
| |
| dojo.dom.destroyNode = function(/*Node*/node){ |
| // summary: |
| // destroy a node (it can not be used any more). For IE, this is the |
| // right function to call to prevent memory leaks. While for other |
| // browsers, this is identical to dojo.dom.removeNode |
| if(node.parentNode){ |
| node = dojo.dom.removeNode(node); |
| } |
| if(node.nodeType != 3){ // ingore TEXT_NODE |
| if(dojo.evalObjPath("dojo.event.browser.clean", false)){ |
| dojo.event.browser.clean(node); |
| } |
| if(dojo.render.html.ie){ |
| node.outerHTML=''; //prevent ugly IE mem leak associated with Node.removeChild (ticket #1727) |
| } |
| } |
| } |
| |
| dojo.dom.removeNode = function(/*Node*/node){ |
| // summary: |
| // if node has a parent, removes node from parent and returns a |
| // reference to the removed child. |
| // To prevent IE memory leak, call destroyNode on the returned node when |
| // it is no longer needed. |
| // node: |
| // the node to remove from its parent. |
| |
| if(node && node.parentNode){ |
| // return a ref to the removed child |
| return node.parentNode.removeChild(node); //Node |
| } |
| } |
| |
| dojo.dom.getAncestors = function(/*Node*/node, /*function?*/filterFunction, /*boolean?*/returnFirstHit){ |
| // summary: |
| // returns all ancestors matching optional filterFunction; will return |
| // only the first if returnFirstHit |
| var ancestors = []; |
| var isFunction = (filterFunction && (filterFunction instanceof Function || typeof filterFunction == "function")); |
| while(node){ |
| if(!isFunction || filterFunction(node)){ |
| ancestors.push(node); |
| } |
| if(returnFirstHit && ancestors.length > 0){ |
| return ancestors[0]; // Node |
| } |
| |
| node = node.parentNode; |
| } |
| if(returnFirstHit){ return null; } |
| return ancestors; // array |
| } |
| |
| dojo.dom.getAncestorsByTag = function(/*Node*/node, /*String*/tag, /*boolean?*/returnFirstHit){ |
| // summary: |
| // returns all ancestors matching tag (as tagName), will only return |
| // first one if returnFirstHit |
| tag = tag.toLowerCase(); |
| return dojo.dom.getAncestors(node, function(el){ |
| return ((el.tagName)&&(el.tagName.toLowerCase() == tag)); |
| }, returnFirstHit); // Node || array |
| } |
| |
| dojo.dom.getFirstAncestorByTag = function(/*Node*/node, /*string*/tag){ |
| // summary: |
| // Returns first ancestor of node with tag tagName |
| return dojo.dom.getAncestorsByTag(node, tag, true); // Node |
| } |
| |
| dojo.dom.isDescendantOf = function(/* Node */node, /* Node */ancestor, /* boolean? */guaranteeDescendant){ |
| // summary |
| // Returns boolean if node is a descendant of ancestor |
| // guaranteeDescendant allows us to be a "true" isDescendantOf function |
| if(guaranteeDescendant && node) { node = node.parentNode; } |
| while(node) { |
| if(node == ancestor){ |
| return true; // boolean |
| } |
| node = node.parentNode; |
| } |
| return false; // boolean |
| } |
| |
| dojo.dom.innerXML = function(/*Node*/node){ |
| // summary: |
| // Implementation of MS's innerXML function. |
| if(node.innerXML){ |
| return node.innerXML; // string |
| }else if (node.xml){ |
| return node.xml; // string |
| }else if(typeof XMLSerializer != "undefined"){ |
| return (new XMLSerializer()).serializeToString(node); // string |
| } |
| } |
| |
| dojo.dom.createDocument = function(){ |
| // summary: |
| // cross-browser implementation of creating an XML document object. |
| var doc = null; |
| var _document = dojo.doc(); |
| |
| if(!dj_undef("ActiveXObject")){ |
| var prefixes = [ "MSXML2", "Microsoft", "MSXML", "MSXML3" ]; |
| for(var i = 0; i<prefixes.length; i++){ |
| try{ |
| doc = new ActiveXObject(prefixes[i]+".XMLDOM"); |
| }catch(e){ /* squelch */ }; |
| |
| if(doc){ break; } |
| } |
| }else if((_document.implementation)&& |
| (_document.implementation.createDocument)){ |
| doc = _document.implementation.createDocument("", "", null); |
| } |
| |
| return doc; // DOMDocument |
| } |
| |
| dojo.dom.createDocumentFromText = function(/*string*/str, /*string?*/mimetype){ |
| // summary: |
| // attempts to create a Document object based on optional mime-type, |
| // using str as the contents of the document |
| if(!mimetype){ mimetype = "text/xml"; } |
| if(!dj_undef("DOMParser")){ |
| var parser = new DOMParser(); |
| return parser.parseFromString(str, mimetype); // DOMDocument |
| }else if(!dj_undef("ActiveXObject")){ |
| var domDoc = dojo.dom.createDocument(); |
| if(domDoc){ |
| domDoc.async = false; |
| domDoc.loadXML(str); |
| return domDoc; // DOMDocument |
| }else{ |
| dojo.debug("toXml didn't work?"); |
| } |
| /* |
| }else if((dojo.render.html.capable)&&(dojo.render.html.safari)){ |
| // FIXME: this doesn't appear to work! |
| // from: http://web-graphics.com/mtarchive/001606.php |
| // var xml = '<?xml version="1.0"?>'+str; |
| var mtype = "text/xml"; |
| var xml = '<?xml version="1.0"?>'+str; |
| var url = "data:"+mtype+";charset=utf-8,"+encodeURIComponent(xml); |
| var req = new XMLHttpRequest(); |
| req.open("GET", url, false); |
| req.overrideMimeType(mtype); |
| req.send(null); |
| return req.responseXML; |
| */ |
| }else{ |
| var _document = dojo.doc(); |
| if(_document.createElement){ |
| // FIXME: this may change all tags to uppercase! |
| var tmp = _document.createElement("xml"); |
| tmp.innerHTML = str; |
| if(_document.implementation && _document.implementation.createDocument){ |
| var xmlDoc = _document.implementation.createDocument("foo", "", null); |
| for(var i = 0; i < tmp.childNodes.length; i++) { |
| xmlDoc.importNode(tmp.childNodes.item(i), true); |
| } |
| return xmlDoc; // DOMDocument |
| } |
| // FIXME: probably not a good idea to have to return an HTML fragment |
| // FIXME: the tmp.doc.firstChild is as tested from IE, so it may not |
| // work that way across the board |
| return ((tmp.document)&& |
| (tmp.document.firstChild ? tmp.document.firstChild : tmp)); // DOMDocument |
| } |
| } |
| return null; |
| } |
| |
| dojo.dom.prependChild = function(/*Element*/node, /*Element*/parent){ |
| // summary: |
| // prepends node to parent's children nodes |
| if(parent.firstChild) { |
| parent.insertBefore(node, parent.firstChild); |
| } else { |
| parent.appendChild(node); |
| } |
| return true; // boolean |
| } |
| |
| dojo.dom.insertBefore = function(/*Node*/node, /*Node*/ref, /*boolean?*/force){ |
| // summary: |
| // Try to insert node before ref |
| if( (force != true)&& |
| (node === ref || node.nextSibling === ref)){ return false; } |
| var parent = ref.parentNode; |
| parent.insertBefore(node, ref); |
| return true; // boolean |
| } |
| |
| dojo.dom.insertAfter = function(/*Node*/node, /*Node*/ref, /*boolean?*/force){ |
| // summary: |
| // Try to insert node after ref |
| var pn = ref.parentNode; |
| if(ref == pn.lastChild){ |
| if((force != true)&&(node === ref)){ |
| return false; // boolean |
| } |
| pn.appendChild(node); |
| }else{ |
| return this.insertBefore(node, ref.nextSibling, force); // boolean |
| } |
| return true; // boolean |
| } |
| |
| dojo.dom.insertAtPosition = function(/*Node*/node, /*Node*/ref, /*string*/position){ |
| // summary: |
| // attempt to insert node in relation to ref based on position |
| if((!node)||(!ref)||(!position)){ |
| return false; // boolean |
| } |
| switch(position.toLowerCase()){ |
| case "before": |
| return dojo.dom.insertBefore(node, ref); // boolean |
| case "after": |
| return dojo.dom.insertAfter(node, ref); // boolean |
| case "first": |
| if(ref.firstChild){ |
| return dojo.dom.insertBefore(node, ref.firstChild); // boolean |
| }else{ |
| ref.appendChild(node); |
| return true; // boolean |
| } |
| break; |
| default: // aka: last |
| ref.appendChild(node); |
| return true; // boolean |
| } |
| } |
| |
| dojo.dom.insertAtIndex = function(/*Node*/node, /*Element*/containingNode, /*number*/insertionIndex){ |
| // summary: |
| // insert node into child nodes nodelist of containingNode at |
| // insertionIndex. insertionIndex should be between 0 and |
| // the number of the childNodes in containingNode. insertionIndex |
| // specifys after how many childNodes in containingNode the node |
| // shall be inserted. If 0 is given, node will be appended to |
| // containingNode. |
| var siblingNodes = containingNode.childNodes; |
| |
| // if there aren't any kids yet, just add it to the beginning |
| |
| if (!siblingNodes.length || siblingNodes.length == insertionIndex){ |
| containingNode.appendChild(node); |
| return true; // boolean |
| } |
| |
| if(insertionIndex == 0){ |
| return dojo.dom.prependChild(node, containingNode); // boolean |
| } |
| // otherwise we need to walk the childNodes |
| // and find our spot |
| |
| return dojo.dom.insertAfter(node, siblingNodes[insertionIndex-1]); // boolean |
| } |
| |
| dojo.dom.textContent = function(/*Node*/node, /*string*/text){ |
| // summary: |
| // implementation of the DOM Level 3 attribute; scan node for text |
| if (arguments.length>1) { |
| var _document = dojo.doc(); |
| dojo.dom.replaceChildren(node, _document.createTextNode(text)); |
| return text; // string |
| } else { |
| if(node.textContent != undefined){ //FF 1.5 |
| return node.textContent; // string |
| } |
| var _result = ""; |
| if (node == null) { return _result; } |
| for (var i = 0; i < node.childNodes.length; i++) { |
| switch (node.childNodes[i].nodeType) { |
| case 1: // ELEMENT_NODE |
| case 5: // ENTITY_REFERENCE_NODE |
| _result += dojo.dom.textContent(node.childNodes[i]); |
| break; |
| case 3: // TEXT_NODE |
| case 2: // ATTRIBUTE_NODE |
| case 4: // CDATA_SECTION_NODE |
| _result += node.childNodes[i].nodeValue; |
| break; |
| default: |
| break; |
| } |
| } |
| return _result; // string |
| } |
| } |
| |
| dojo.dom.hasParent = function(/*Node*/node){ |
| // summary: |
| // returns whether or not node is a child of another node. |
| return Boolean(node && node.parentNode && dojo.dom.isNode(node.parentNode)); // boolean |
| } |
| |
| /** |
| * Examples: |
| * |
| * myFooNode = <foo /> |
| * isTag(myFooNode, "foo"); // returns "foo" |
| * isTag(myFooNode, "bar"); // returns "" |
| * isTag(myFooNode, "FOO"); // returns "" |
| * isTag(myFooNode, "hey", "foo", "bar"); // returns "foo" |
| **/ |
| dojo.dom.isTag = function(/* Node */node /* ... */){ |
| // summary: |
| // determines if node has any of the provided tag names and returns |
| // the tag name that matches, empty string otherwise. |
| if(node && node.tagName) { |
| for(var i=1; i<arguments.length; i++){ |
| if(node.tagName==String(arguments[i])){ |
| return String(arguments[i]); // string |
| } |
| } |
| } |
| return ""; // string |
| } |
| |
| dojo.dom.setAttributeNS = function( /*Element*/elem, /*string*/namespaceURI, |
| /*string*/attrName, /*string*/attrValue){ |
| // summary: |
| // implementation of DOM2 setAttributeNS that works cross browser. |
| if(elem == null || ((elem == undefined)&&(typeof elem == "undefined"))){ |
| dojo.raise("No element given to dojo.dom.setAttributeNS"); |
| } |
| |
| if(!((elem.setAttributeNS == undefined)&&(typeof elem.setAttributeNS == "undefined"))){ // w3c |
| elem.setAttributeNS(namespaceURI, attrName, attrValue); |
| }else{ // IE |
| // get a root XML document |
| var ownerDoc = elem.ownerDocument; |
| var attribute = ownerDoc.createNode( |
| 2, // node type |
| attrName, |
| namespaceURI |
| ); |
| |
| // set value |
| attribute.nodeValue = attrValue; |
| |
| // attach to element |
| elem.setAttributeNode(attribute); |
| } |
| } |
| |
| dojo.provide("dojo.undo.browser"); |
| |
| |
| try{ |
| if((!djConfig["preventBackButtonFix"])&&(!dojo.hostenv.post_load_)){ |
| document.write("<iframe style='border: 0px; width: 1px; height: 1px; position: absolute; bottom: 0px; right: 0px; visibility: visible;' name='djhistory' id='djhistory' src='" + (djConfig["dojoIframeHistoryUrl"] || dojo.hostenv.getBaseScriptUri()+'iframe_history.html') + "'></iframe>"); |
| } |
| }catch(e){/* squelch */} |
| |
| if(dojo.render.html.opera){ |
| dojo.debug("Opera is not supported with dojo.undo.browser, so back/forward detection will not work."); |
| } |
| |
| dojo.undo.browser = { |
| initialHref: (!dj_undef("window")) ? window.location.href : "", |
| initialHash: (!dj_undef("window")) ? window.location.hash : "", |
| |
| moveForward: false, |
| historyStack: [], |
| forwardStack: [], |
| historyIframe: null, |
| bookmarkAnchor: null, |
| locationTimer: null, |
| |
| /** |
| * |
| */ |
| setInitialState: function(/*Object*/args){ |
| //summary: Sets the state object and back callback for the very first page that is loaded. |
| //description: It is recommended that you call this method as part of an event listener that is registered via |
| //dojo.addOnLoad(). |
| //args: Object |
| // See the addToHistory() function for the list of valid args properties. |
| this.initialState = this._createState(this.initialHref, args, this.initialHash); |
| }, |
| |
| //FIXME: Would like to support arbitrary back/forward jumps. Have to rework iframeLoaded among other things. |
| //FIXME: is there a slight race condition in moz using change URL with the timer check and when |
| // the hash gets set? I think I have seen a back/forward call in quick succession, but not consistent. |
| addToHistory: function(args){ |
| //summary: adds a state object (args) to the history list. You must set |
| //djConfig.preventBackButtonFix = false to use dojo.undo.browser. |
| |
| //args: Object |
| // args can have the following properties: |
| // To support getting back button notifications, the object argument should implement a |
| // function called either "back", "backButton", or "handle". The string "back" will be |
| // passed as the first and only argument to this callback. |
| // - To support getting forward button notifications, the object argument should implement a |
| // function called either "forward", "forwardButton", or "handle". The string "forward" will be |
| // passed as the first and only argument to this callback. |
| // - If you want the browser location string to change, define "changeUrl" on the object. If the |
| // value of "changeUrl" is true, then a unique number will be appended to the URL as a fragment |
| // identifier (http://some.domain.com/path#uniquenumber). If it is any other value that does |
| // not evaluate to false, that value will be used as the fragment identifier. For example, |
| // if changeUrl: 'page1', then the URL will look like: http://some.domain.com/path#page1 |
| // Full example: |
| // dojo.undo.browser.addToHistory({ |
| // back: function() { alert('back pressed'); }, |
| // forward: function() { alert('forward pressed'); }, |
| // changeUrl: true |
| // }); |
| // |
| // BROWSER NOTES: |
| // Safari 1.2: |
| // back button "works" fine, however it's not possible to actually |
| // DETECT that you've moved backwards by inspecting window.location. |
| // Unless there is some other means of locating. |
| // FIXME: perhaps we can poll on history.length? |
| // Safari 2.0.3+ (and probably 1.3.2+): |
| // works fine, except when changeUrl is used. When changeUrl is used, |
| // Safari jumps all the way back to whatever page was shown before |
| // the page that uses dojo.undo.browser support. |
| // IE 5.5 SP2: |
| // back button behavior is macro. It does not move back to the |
| // previous hash value, but to the last full page load. This suggests |
| // that the iframe is the correct way to capture the back button in |
| // these cases. |
| // Don't test this page using local disk for MSIE. MSIE will not create |
| // a history list for iframe_history.html if served from a file: URL. |
| // The XML served back from the XHR tests will also not be properly |
| // created if served from local disk. Serve the test pages from a web |
| // server to test in that browser. |
| // IE 6.0: |
| // same behavior as IE 5.5 SP2 |
| // Firefox 1.0+: |
| // the back button will return us to the previous hash on the same |
| // page, thereby not requiring an iframe hack, although we do then |
| // need to run a timer to detect inter-page movement. |
| |
| //If addToHistory is called, then that means we prune the |
| //forward stack -- the user went back, then wanted to |
| //start a new forward path. |
| this.forwardStack = []; |
| |
| var hash = null; |
| var url = null; |
| if(!this.historyIframe){ |
| if(djConfig["useXDomain"] && !djConfig["dojoIframeHistoryUrl"]){ |
| dojo.debug("dojo.undo.browser: When using cross-domain Dojo builds," |
| + " please save iframe_history.html to your domain and set djConfig.dojoIframeHistoryUrl" |
| + " to the path on your domain to iframe_history.html"); |
| } |
| this.historyIframe = window.frames["djhistory"]; |
| } |
| if(!this.bookmarkAnchor){ |
| this.bookmarkAnchor = document.createElement("a"); |
| dojo.body().appendChild(this.bookmarkAnchor); |
| this.bookmarkAnchor.style.display = "none"; |
| } |
| if(args["changeUrl"]){ |
| hash = "#"+ ((args["changeUrl"]!==true) ? args["changeUrl"] : (new Date()).getTime()); |
| |
| //If the current hash matches the new one, just replace the history object with |
| //this new one. It doesn't make sense to track different state objects for the same |
| //logical URL. This matches the browser behavior of only putting in one history |
| //item no matter how many times you click on the same #hash link, at least in Firefox |
| //and Safari, and there is no reliable way in those browsers to know if a #hash link |
| //has been clicked on multiple times. So making this the standard behavior in all browsers |
| //so that dojo.undo.browser's behavior is the same in all browsers. |
| if(this.historyStack.length == 0 && this.initialState.urlHash == hash){ |
| this.initialState = this._createState(url, args, hash); |
| return; |
| }else if(this.historyStack.length > 0 && this.historyStack[this.historyStack.length - 1].urlHash == hash){ |
| this.historyStack[this.historyStack.length - 1] = this._createState(url, args, hash); |
| return; |
| } |
| |
| this.changingUrl = true; |
| setTimeout("window.location.href = '"+hash+"'; dojo.undo.browser.changingUrl = false;", 1); |
| this.bookmarkAnchor.href = hash; |
| |
| if(dojo.render.html.ie){ |
| url = this._loadIframeHistory(); |
| |
| var oldCB = args["back"]||args["backButton"]||args["handle"]; |
| |
| //The function takes handleName as a parameter, in case the |
| //callback we are overriding was "handle". In that case, |
| //we will need to pass the handle name to handle. |
| var tcb = function(handleName){ |
| if(window.location.hash != ""){ |
| setTimeout("window.location.href = '"+hash+"';", 1); |
| } |
| //Use apply to set "this" to args, and to try to avoid memory leaks. |
| oldCB.apply(this, [handleName]); |
| } |
| |
| //Set interceptor function in the right place. |
| if(args["back"]){ |
| args.back = tcb; |
| }else if(args["backButton"]){ |
| args.backButton = tcb; |
| }else if(args["handle"]){ |
| args.handle = tcb; |
| } |
| |
| var oldFW = args["forward"]||args["forwardButton"]||args["handle"]; |
| |
| //The function takes handleName as a parameter, in case the |
| //callback we are overriding was "handle". In that case, |
| //we will need to pass the handle name to handle. |
| var tfw = function(handleName){ |
| if(window.location.hash != ""){ |
| window.location.href = hash; |
| } |
| if(oldFW){ // we might not actually have one |
| //Use apply to set "this" to args, and to try to avoid memory leaks. |
| oldFW.apply(this, [handleName]); |
| } |
| } |
| |
| //Set interceptor function in the right place. |
| if(args["forward"]){ |
| args.forward = tfw; |
| }else if(args["forwardButton"]){ |
| args.forwardButton = tfw; |
| }else if(args["handle"]){ |
| args.handle = tfw; |
| } |
| |
| }else if(dojo.render.html.moz){ |
| // start the timer |
| if(!this.locationTimer){ |
| this.locationTimer = setInterval("dojo.undo.browser.checkLocation();", 200); |
| } |
| } |
| }else{ |
| url = this._loadIframeHistory(); |
| } |
| |
| this.historyStack.push(this._createState(url, args, hash)); |
| }, |
| |
| checkLocation: function(){ |
| //summary: private method. Do not call this directly. |
| if (!this.changingUrl){ |
| var hsl = this.historyStack.length; |
| |
| if((window.location.hash == this.initialHash||window.location.href == this.initialHref)&&(hsl == 1)){ |
| // FIXME: could this ever be a forward button? |
| // we can't clear it because we still need to check for forwards. Ugg. |
| // clearInterval(this.locationTimer); |
| this.handleBackButton(); |
| return; |
| } |
| |
| // first check to see if we could have gone forward. We always halt on |
| // a no-hash item. |
| if(this.forwardStack.length > 0){ |
| if(this.forwardStack[this.forwardStack.length-1].urlHash == window.location.hash){ |
| this.handleForwardButton(); |
| return; |
| } |
| } |
| |
| // ok, that didn't work, try someplace back in the history stack |
| if((hsl >= 2)&&(this.historyStack[hsl-2])){ |
| if(this.historyStack[hsl-2].urlHash==window.location.hash){ |
| this.handleBackButton(); |
| return; |
| } |
| } |
| } |
| }, |
| |
| iframeLoaded: function(evt, ifrLoc){ |
| //summary: private method. Do not call this directly. |
| if(!dojo.render.html.opera){ |
| var query = this._getUrlQuery(ifrLoc.href); |
| if(query == null){ |
| // alert("iframeLoaded"); |
| // we hit the end of the history, so we should go back |
| if(this.historyStack.length == 1){ |
| this.handleBackButton(); |
| } |
| return; |
| } |
| if(this.moveForward){ |
| // we were expecting it, so it's not either a forward or backward movement |
| this.moveForward = false; |
| return; |
| } |
| |
| //Check the back stack first, since it is more likely. |
| //Note that only one step back or forward is supported. |
| if(this.historyStack.length >= 2 && query == this._getUrlQuery(this.historyStack[this.historyStack.length-2].url)){ |
| this.handleBackButton(); |
| } |
| else if(this.forwardStack.length > 0 && query == this._getUrlQuery(this.forwardStack[this.forwardStack.length-1].url)){ |
| this.handleForwardButton(); |
| } |
| } |
| }, |
| |
| handleBackButton: function(){ |
| //summary: private method. Do not call this directly. |
| |
| //The "current" page is always at the top of the history stack. |
| var current = this.historyStack.pop(); |
| if(!current){ return; } |
| var last = this.historyStack[this.historyStack.length-1]; |
| if(!last && this.historyStack.length == 0){ |
| last = this.initialState; |
| } |
| if (last){ |
| if(last.kwArgs["back"]){ |
| last.kwArgs["back"](); |
| }else if(last.kwArgs["backButton"]){ |
| last.kwArgs["backButton"](); |
| }else if(last.kwArgs["handle"]){ |
| last.kwArgs.handle("back"); |
| } |
| } |
| this.forwardStack.push(current); |
| }, |
| |
| handleForwardButton: function(){ |
| //summary: private method. Do not call this directly. |
| |
| var last = this.forwardStack.pop(); |
| if(!last){ return; } |
| if(last.kwArgs["forward"]){ |
| last.kwArgs.forward(); |
| }else if(last.kwArgs["forwardButton"]){ |
| last.kwArgs.forwardButton(); |
| }else if(last.kwArgs["handle"]){ |
| last.kwArgs.handle("forward"); |
| } |
| this.historyStack.push(last); |
| }, |
| |
| _createState: function(url, args, hash){ |
| //summary: private method. Do not call this directly. |
| |
| return {"url": url, "kwArgs": args, "urlHash": hash}; //Object |
| }, |
| |
| _getUrlQuery: function(url){ |
| //summary: private method. Do not call this directly. |
| var segments = url.split("?"); |
| if (segments.length < 2){ |
| return null; //null |
| } |
| else{ |
| return segments[1]; //String |
| } |
| }, |
| |
| _loadIframeHistory: function(){ |
| //summary: private method. Do not call this directly. |
| var url = (djConfig["dojoIframeHistoryUrl"] || dojo.hostenv.getBaseScriptUri()+'iframe_history.html') |
| + "?" + (new Date()).getTime(); |
| this.moveForward = true; |
| dojo.io.setIFrameSrc(this.historyIframe, url, false); |
| return url; //String |
| } |
| } |
| |
| dojo.provide("dojo.io.BrowserIO"); |
| |
| |
| |
| |
| |
| |
| |
| |
| if(!dj_undef("window")) { |
| |
| dojo.io.checkChildrenForFile = function(/*DOMNode*/node){ |
| //summary: Checks any child nodes of node for an input type="file" element. |
| var hasFile = false; |
| var inputs = node.getElementsByTagName("input"); |
| dojo.lang.forEach(inputs, function(input){ |
| if(hasFile){ return; } |
| if(input.getAttribute("type")=="file"){ |
| hasFile = true; |
| } |
| }); |
| return hasFile; //boolean |
| } |
| |
| dojo.io.formHasFile = function(/*DOMNode*/formNode){ |
| //summary: Just calls dojo.io.checkChildrenForFile(). |
| return dojo.io.checkChildrenForFile(formNode); //boolean |
| } |
| |
| dojo.io.updateNode = function(/*DOMNode*/node, /*String or Object*/urlOrArgs){ |
| //summary: Updates a DOMnode with the result of a dojo.io.bind() call. |
| //node: DOMNode |
| //urlOrArgs: String or Object |
| // Either a String that has an URL, or an object containing dojo.io.bind() |
| // arguments. |
| node = dojo.byId(node); |
| var args = urlOrArgs; |
| if(dojo.lang.isString(urlOrArgs)){ |
| args = { url: urlOrArgs }; |
| } |
| args.mimetype = "text/html"; |
| args.load = function(t, d, e){ |
| while(node.firstChild){ |
| dojo.dom.destroyNode(node.firstChild); |
| } |
| node.innerHTML = d; |
| }; |
| dojo.io.bind(args); |
| } |
| |
| dojo.io.formFilter = function(/*DOMNode*/node) { |
| //summary: Returns true if the node is an input element that is enabled, has |
| //a name, and whose type is one of the following values: ["file", "submit", "image", "reset", "button"] |
| var type = (node.type||"").toLowerCase(); |
| return !node.disabled && node.name |
| && !dojo.lang.inArray(["file", "submit", "image", "reset", "button"], type); //boolean |
| } |
| |
| // TODO: Move to htmlUtils |
| dojo.io.encodeForm = function(/*DOMNode*/formNode, /*String?*/encoding, /*Function?*/formFilter){ |
| //summary: Converts the names and values of form elements into an URL-encoded |
| //string (name=value&name=value...). |
| //formNode: DOMNode |
| //encoding: String? |
| // The encoding to use for the values. Specify a string that starts with |
| // "utf" (for instance, "utf8"), to use encodeURIComponent() as the encoding |
| // function. Otherwise, dojo.string.encodeAscii will be used. |
| //formFilter: Function? |
| // A function used to filter out form elements. The element node will be passed |
| // to the formFilter function, and a boolean result is expected (true indicating |
| // indicating that the element should have its name/value included in the output). |
| // If no formFilter is specified, then dojo.io.formFilter() will be used. |
| if((!formNode)||(!formNode.tagName)||(!formNode.tagName.toLowerCase() == "form")){ |
| dojo.raise("Attempted to encode a non-form element."); |
| } |
| if(!formFilter) { formFilter = dojo.io.formFilter; } |
| var enc = /utf/i.test(encoding||"") ? encodeURIComponent : dojo.string.encodeAscii; |
| var values = []; |
| |
| for(var i = 0; i < formNode.elements.length; i++){ |
| var elm = formNode.elements[i]; |
| if(!elm || elm.tagName.toLowerCase() == "fieldset" || !formFilter(elm)) { continue; } |
| var name = enc(elm.name); |
| var type = elm.type.toLowerCase(); |
| |
| if(type == "select-multiple"){ |
| for(var j = 0; j < elm.options.length; j++){ |
| if(elm.options[j].selected) { |
| values.push(name + "=" + enc(elm.options[j].value)); |
| } |
| } |
| }else if(dojo.lang.inArray(["radio", "checkbox"], type)){ |
| if(elm.checked){ |
| values.push(name + "=" + enc(elm.value)); |
| } |
| }else{ |
| values.push(name + "=" + enc(elm.value)); |
| } |
| } |
| |
| // now collect input type="image", which doesn't show up in the elements array |
| var inputs = formNode.getElementsByTagName("input"); |
| for(var i = 0; i < inputs.length; i++) { |
| var input = inputs[i]; |
| if(input.type.toLowerCase() == "image" && input.form == formNode |
| && formFilter(input)) { |
| var name = enc(input.name); |
| values.push(name + "=" + enc(input.value)); |
| values.push(name + ".x=0"); |
| values.push(name + ".y=0"); |
| } |
| } |
| return values.join("&") + "&"; //String |
| } |
| |
| dojo.io.FormBind = function(/*DOMNode or Object*/args) { |
| //summary: constructor for a dojo.io.FormBind object. See the Dojo Book for |
| //some information on usage: http://manual.dojotoolkit.org/WikiHome/DojoDotBook/Book23 |
| //args: DOMNode or Object |
| // args can either be the DOMNode for a form element, or an object containing |
| // dojo.io.bind() arguments, one of which should be formNode with the value of |
| // a form element DOMNode. |
| this.bindArgs = {}; |
| |
| if(args && args.formNode) { |
| this.init(args); |
| } else if(args) { |
| this.init({formNode: args}); |
| } |
| } |
| dojo.lang.extend(dojo.io.FormBind, { |
| form: null, |
| |
| bindArgs: null, |
| |
| clickedButton: null, |
| |
| init: function(/*DOMNode or Object*/args) { |
| //summary: Internal function called by the dojo.io.FormBind() constructor |
| //do not call this method directly. |
| var form = dojo.byId(args.formNode); |
| |
| if(!form || !form.tagName || form.tagName.toLowerCase() != "form") { |
| throw new Error("FormBind: Couldn't apply, invalid form"); |
| } else if(this.form == form) { |
| return; |
| } else if(this.form) { |
| throw new Error("FormBind: Already applied to a form"); |
| } |
| |
| dojo.lang.mixin(this.bindArgs, args); |
| this.form = form; |
| |
| this.connect(form, "onsubmit", "submit"); |
| |
| for(var i = 0; i < form.elements.length; i++) { |
| var node = form.elements[i]; |
| if(node && node.type && dojo.lang.inArray(["submit", "button"], node.type.toLowerCase())) { |
| this.connect(node, "onclick", "click"); |
| } |
| } |
| |
| var inputs = form.getElementsByTagName("input"); |
| for(var i = 0; i < inputs.length; i++) { |
| var input = inputs[i]; |
| if(input.type.toLowerCase() == "image" && input.form == form) { |
| this.connect(input, "onclick", "click"); |
| } |
| } |
| }, |
| |
| onSubmit: function(/*DOMNode*/form) { |
| //summary: Function used to verify that the form is OK to submit. |
| //Override this function if you want specific form validation done. |
| return true; //boolean |
| }, |
| |
| submit: function(/*Event*/e) { |
| //summary: internal function that is connected as a listener to the |
| //form's onsubmit event. |
| e.preventDefault(); |
| if(this.onSubmit(this.form)) { |
| dojo.io.bind(dojo.lang.mixin(this.bindArgs, { |
| formFilter: dojo.lang.hitch(this, "formFilter") |
| })); |
| } |
| }, |
| |
| click: function(/*Event*/e) { |
| //summary: internal method that is connected as a listener to the |
| //form's elements whose click event can submit a form. |
| var node = e.currentTarget; |
| if(node.disabled) { return; } |
| this.clickedButton = node; |
| }, |
| |
| formFilter: function(/*DOMNode*/node) { |
| //summary: internal function used to know which form element values to include |
| // in the dojo.io.bind() request. |
| var type = (node.type||"").toLowerCase(); |
| var accept = false; |
| if(node.disabled || !node.name) { |
| accept = false; |
| } else if(dojo.lang.inArray(["submit", "button", "image"], type)) { |
| if(!this.clickedButton) { this.clickedButton = node; } |
| accept = node == this.clickedButton; |
| } else { |
| accept = !dojo.lang.inArray(["file", "submit", "reset", "button"], type); |
| } |
| return accept; //boolean |
| }, |
| |
| // in case you don't have dojo.event.* pulled in |
| connect: function(/*Object*/srcObj, /*Function*/srcFcn, /*Function*/targetFcn) { |
| //summary: internal function used to connect event listeners to form elements |
| //that trigger events. Used in case dojo.event is not loaded. |
| if(dojo.evalObjPath("dojo.event.connect")) { |
| dojo.event.connect(srcObj, srcFcn, this, targetFcn); |
| } else { |
| var fcn = dojo.lang.hitch(this, targetFcn); |
| srcObj[srcFcn] = function(e) { |
| if(!e) { e = window.event; } |
| if(!e.currentTarget) { e.currentTarget = e.srcElement; } |
| if(!e.preventDefault) { e.preventDefault = function() { window.event.returnValue = false; } } |
| fcn(e); |
| } |
| } |
| } |
| }); |
| |
| dojo.io.XMLHTTPTransport = new function(){ |
| //summary: The object that implements the dojo.io.bind transport for XMLHttpRequest. |
| var _this = this; |
| |
| var _cache = {}; // FIXME: make this public? do we even need to? |
| this.useCache = false; // if this is true, we'll cache unless kwArgs.useCache = false |
| this.preventCache = false; // if this is true, we'll always force GET requests to cache |
| |
| // FIXME: Should this even be a function? or do we just hard code it in the next 2 functions? |
| function getCacheKey(url, query, method) { |
| return url + "|" + query + "|" + method.toLowerCase(); |
| } |
| |
| function addToCache(url, query, method, http) { |
| _cache[getCacheKey(url, query, method)] = http; |
| } |
| |
| function getFromCache(url, query, method) { |
| return _cache[getCacheKey(url, query, method)]; |
| } |
| |
| this.clearCache = function() { |
| _cache = {}; |
| } |
| |
| // moved successful load stuff here |
| function doLoad(kwArgs, http, url, query, useCache) { |
| if( ((http.status>=200)&&(http.status<300))|| // allow any 2XX response code |
| (http.status==304)|| // get it out of the cache |
| (http.status==1223)|| // Internet Explorer mangled the status code |
| (location.protocol=="file:" && (http.status==0 || http.status==undefined))|| |
| (location.protocol=="chrome:" && (http.status==0 || http.status==undefined)) |
| ){ |
| var ret; |
| if(kwArgs.method.toLowerCase() == "head"){ |
| var headers = http.getAllResponseHeaders(); |
| ret = {}; |
| ret.toString = function(){ return headers; } |
| var values = headers.split(/[\r\n]+/g); |
| for(var i = 0; i < values.length; i++) { |
| var pair = values[i].match(/^([^:]+)\s*:\s*(.+)$/i); |
| if(pair) { |
| ret[pair[1]] = pair[2]; |
| } |
| } |
| }else if(kwArgs.mimetype == "text/javascript"){ |
| try{ |
| ret = dj_eval(http.responseText); |
| }catch(e){ |
| dojo.debug(e); |
| dojo.debug(http.responseText); |
| ret = null; |
| } |
| }else if(kwArgs.mimetype.substr(0, 9) == "text/json" || kwArgs.mimetype.substr(0, 16) == "application/json"){ |
| try{ |
| ret = dj_eval("("+kwArgs.jsonFilter(http.responseText)+")"); |
| }catch(e){ |
| dojo.debug(e); |
| dojo.debug(http.responseText); |
| ret = false; |
| } |
| }else if((kwArgs.mimetype == "application/xml")|| |
| (kwArgs.mimetype == "text/xml")){ |
| ret = http.responseXML; |
| if(!ret || typeof ret == "string" || !http.getResponseHeader("Content-Type")) { |
| ret = dojo.dom.createDocumentFromText(http.responseText); |
| } |
| }else{ |
| ret = http.responseText; |
| } |
| |
| if(useCache){ // only cache successful responses |
| addToCache(url, query, kwArgs.method, http); |
| } |
| kwArgs[(typeof kwArgs.load == "function") ? "load" : "handle"]("load", ret, http, kwArgs); |
| }else{ |
| var errObj = new dojo.io.Error("XMLHttpTransport Error: "+http.status+" "+http.statusText); |
| kwArgs[(typeof kwArgs.error == "function") ? "error" : "handle"]("error", errObj, http, kwArgs); |
| } |
| } |
| |
| // set headers (note: Content-Type will get overriden if kwArgs.contentType is set) |
| function setHeaders(http, kwArgs){ |
| if(kwArgs["headers"]) { |
| for(var header in kwArgs["headers"]) { |
| if(header.toLowerCase() == "content-type" && !kwArgs["contentType"]) { |
| kwArgs["contentType"] = kwArgs["headers"][header]; |
| } else { |
| http.setRequestHeader(header, kwArgs["headers"][header]); |
| } |
| } |
| } |
| } |
| |
| this.inFlight = []; |
| this.inFlightTimer = null; |
| |
| this.startWatchingInFlight = function(){ |
| //summary: internal method used to trigger a timer to watch all inflight |
| //XMLHttpRequests. |
| if(!this.inFlightTimer){ |
| // setInterval broken in mozilla x86_64 in some circumstances, see |
| // https://bugzilla.mozilla.org/show_bug.cgi?id=344439 |
| // using setTimeout instead |
| this.inFlightTimer = setTimeout("dojo.io.XMLHTTPTransport.watchInFlight();", 10); |
| } |
| } |
| |
| this.watchInFlight = function(){ |
| //summary: internal method that checks each inflight XMLHttpRequest to see |
| //if it has completed or if the timeout situation applies. |
| var now = null; |
| // make sure sync calls stay thread safe, if this callback is called during a sync call |
| // and this results in another sync call before the first sync call ends the browser hangs |
| if(!dojo.hostenv._blockAsync && !_this._blockAsync){ |
| for(var x=this.inFlight.length-1; x>=0; x--){ |
| try{ |
| var tif = this.inFlight[x]; |
| if(!tif || tif.http._aborted || !tif.http.readyState){ |
| this.inFlight.splice(x, 1); continue; |
| } |
| if(4==tif.http.readyState){ |
| // remove it so we can clean refs |
| this.inFlight.splice(x, 1); |
| doLoad(tif.req, tif.http, tif.url, tif.query, tif.useCache); |
| }else if (tif.startTime){ |
| //See if this is a timeout case. |
| if(!now){ |
| now = (new Date()).getTime(); |
| } |
| if(tif.startTime + (tif.req.timeoutSeconds * 1000) < now){ |
| //Stop the request. |
| if(typeof tif.http.abort == "function"){ |
| tif.http.abort(); |
| } |
| |
| // remove it so we can clean refs |
| this.inFlight.splice(x, 1); |
| tif.req[(typeof tif.req.timeout == "function") ? "timeout" : "handle"]("timeout", null, tif.http, tif.req); |
| } |
| } |
| }catch(e){ |
| try{ |
| var errObj = new dojo.io.Error("XMLHttpTransport.watchInFlight Error: " + e); |
| tif.req[(typeof tif.req.error == "function") ? "error" : "handle"]("error", errObj, tif.http, tif.req); |
| }catch(e2){ |
| dojo.debug("XMLHttpTransport error callback failed: " + e2); |
| } |
| } |
| } |
| } |
| |
| clearTimeout(this.inFlightTimer); |
| if(this.inFlight.length == 0){ |
| this.inFlightTimer = null; |
| return; |
| } |
| this.inFlightTimer = setTimeout("dojo.io.XMLHTTPTransport.watchInFlight();", 10); |
| } |
| |
| var hasXmlHttp = dojo.hostenv.getXmlhttpObject() ? true : false; |
| this.canHandle = function(/*dojo.io.Request*/kwArgs){ |
| //summary: Tells dojo.io.bind() if this is a good transport to |
| //use for the particular type of request. This type of transport cannot |
| //handle forms that have an input type="file" element. |
| |
| // FIXME: we need to determine when form values need to be |
| // multi-part mime encoded and avoid using this transport for those |
| // requests. |
| var mlc = kwArgs["mimetype"].toLowerCase()||""; |
| return hasXmlHttp |
| && ( |
| ( |
| dojo.lang.inArray([ |
| "text/plain", "text/html", "application/xml", |
| "text/xml", "text/javascript" |
| ], mlc |
| ) |
| ) || ( |
| mlc.substr(0, 9) == "text/json" || mlc.substr(0, 16) == "application/json" |
| ) |
| ) |
| && !( kwArgs["formNode"] && dojo.io.formHasFile(kwArgs["formNode"]) ); //boolean |
| } |
| |
| this.multipartBoundary = "45309FFF-BD65-4d50-99C9-36986896A96F"; // unique guid as a boundary value for multipart posts |
| |
| this.bind = function(/*dojo.io.Request*/kwArgs){ |
| //summary: function that sends the request to the server. |
| |
| //This function will attach an abort() function to the kwArgs dojo.io.Request object, |
| //so if you need to abort the request, you can call that method on the request object. |
| //The following are acceptable properties in kwArgs (in addition to the |
| //normal dojo.io.Request object properties). |
| //url: String: URL the server URL to use for the request. |
| //method: String: the HTTP method to use (GET, POST, etc...). |
| //mimetype: Specifies what format the result data should be given to the load/handle callback. Valid values are: |
| // text/javascript, text/json, application/json, application/xml, text/xml. Any other mimetype will give back a text |
| // string. |
| //transport: String: specify "XMLHTTPTransport" to force the use of this XMLHttpRequest transport. |
| //headers: Object: The object property names and values will be sent as HTTP request header |
| // names and values. |
| //sendTransport: boolean: If true, then dojo.transport=xmlhttp will be added to the request. |
| //encoding: String: The type of encoding to use when dealing with the content kwArgs property. |
| //content: Object: The content object is converted into a name=value&name=value string, by |
| // using dojo.io.argsFromMap(). The encoding kwArgs property is passed to dojo.io.argsFromMap() |
| // for use in encoding the names and values. The resulting string is added to the request. |
| //formNode: DOMNode: a form element node. This should not normally be used. Use new dojo.io.FormBind() instead. |
| // If formNode is used, then the names and values of the form elements will be converted |
| // to a name=value&name=value string and added to the request. The encoding kwArgs property is used |
| // to encode the names and values. |
| //postContent: String: Raw name=value&name=value string to be included as part of the request. |
| //back or backButton: Function: A function to be called if the back button is pressed. If this kwArgs property |
| // is used, then back button support via dojo.undo.browser will be used. See notes for dojo.undo.browser on usage. |
| // You need to set djConfig.preventBackButtonFix = false to enable back button support. |
| //changeUrl: boolean or String: Used as part of back button support. See notes for dojo.undo.browser on usage. |
| //user: String: The user name. Used in conjuction with password. Passed to XMLHttpRequest.open(). |
| //password: String: The user's password. Used in conjuction with user. Passed to XMLHttpRequest.open(). |
| //file: Object or Array of Objects: an object simulating a file to be uploaded. file objects should have the following properties: |
| // name or fileName: the name of the file |
| // contentType: the MIME content type for the file. |
| // content: the actual content of the file. |
| //multipart: boolean: indicates whether this should be a multipart mime request. If kwArgs.file exists, then this |
| // property is set to true automatically. |
| //sync: boolean: if true, then a synchronous XMLHttpRequest call is done, |
| // if false (the default), then an asynchronous call is used. |
| //preventCache: boolean: If true, then a cache busting parameter is added to the request URL. |
| // default value is false. |
| //useCache: boolean: If true, then XMLHttpTransport will keep an internal cache of the server |
| // response and use that response if a similar request is done again. |
| // A similar request is one that has the same URL, query string and HTTP method value. |
| // default is false. |
| if(!kwArgs["url"]){ |
| // are we performing a history action? |
| if( !kwArgs["formNode"] |
| && (kwArgs["backButton"] || kwArgs["back"] || kwArgs["changeUrl"] || kwArgs["watchForURL"]) |
| && (!djConfig.preventBackButtonFix)) { |
| dojo.deprecated("Using dojo.io.XMLHTTPTransport.bind() to add to browser history without doing an IO request", |
| "Use dojo.undo.browser.addToHistory() instead.", "0.4"); |
| dojo.undo.browser.addToHistory(kwArgs); |
| return true; |
| } |
| } |
| |
| // build this first for cache purposes |
| var url = kwArgs.url; |
| var query = ""; |
| if(kwArgs["formNode"]){ |
| var ta = kwArgs.formNode.getAttribute("action"); |
| if((ta)&&(!kwArgs["url"])){ url = ta; } |
| var tp = kwArgs.formNode.getAttribute("method"); |
| if((tp)&&(!kwArgs["method"])){ kwArgs.method = tp; } |
| query += dojo.io.encodeForm(kwArgs.formNode, kwArgs.encoding, kwArgs["formFilter"]); |
| } |
| |
| if(url.indexOf("#") > -1) { |
| dojo.debug("Warning: dojo.io.bind: stripping hash values from url:", url); |
| url = url.split("#")[0]; |
| } |
| |
| if(kwArgs["file"]){ |
| // force post for file transfer |
| kwArgs.method = "post"; |
| } |
| |
| if(!kwArgs["method"]){ |
| kwArgs.method = "get"; |
| } |
| |
| // guess the multipart value |
| if(kwArgs.method.toLowerCase() == "get"){ |
| // GET cannot use multipart |
| kwArgs.multipart = false; |
| }else{ |
| if(kwArgs["file"]){ |
| // enforce multipart when sending files |
| kwArgs.multipart = true; |
| }else if(!kwArgs["multipart"]){ |
| // default |
| kwArgs.multipart = false; |
| } |
| } |
| |
| if(kwArgs["backButton"] || kwArgs["back"] || kwArgs["changeUrl"]){ |
| dojo.undo.browser.addToHistory(kwArgs); |
| } |
| |
| var content = kwArgs["content"] || {}; |
| |
| if(kwArgs.sendTransport) { |
| content["dojo.transport"] = "xmlhttp"; |
| } |
| |
| do { // break-block |
| if(kwArgs.postContent){ |
| query = kwArgs.postContent; |
| break; |
| } |
| |
| if(content) { |
| query += dojo.io.argsFromMap(content, kwArgs.encoding); |
| } |
| |
| if(kwArgs.method.toLowerCase() == "get" || !kwArgs.multipart){ |
| break; |
| } |
| |
| var t = []; |
| if(query.length){ |
| var q = query.split("&"); |
| for(var i = 0; i < q.length; ++i){ |
| if(q[i].length){ |
| var p = q[i].split("="); |
| t.push( "--" + this.multipartBoundary, |
| "Content-Disposition: form-data; name=\"" + p[0] + "\"", |
| "", |
| p[1]); |
| } |
| } |
| } |
| |
| if(kwArgs.file){ |
| if(dojo.lang.isArray(kwArgs.file)){ |
| for(var i = 0; i < kwArgs.file.length; ++i){ |
| var o = kwArgs.file[i]; |
| t.push( "--" + this.multipartBoundary, |
| "Content-Disposition: form-data; name=\"" + o.name + "\"; filename=\"" + ("fileName" in o ? o.fileName : o.name) + "\"", |
| "Content-Type: " + ("contentType" in o ? o.contentType : "application/octet-stream"), |
| "", |
| o.content); |
| } |
| }else{ |
| var o = kwArgs.file; |
| t.push( "--" + this.multipartBoundary, |
| "Content-Disposition: form-data; name=\"" + o.name + "\"; filename=\"" + ("fileName" in o ? o.fileName : o.name) + "\"", |
| "Content-Type: " + ("contentType" in o ? o.contentType : "application/octet-stream"), |
| "", |
| o.content); |
| } |
| } |
| |
| if(t.length){ |
| t.push("--"+this.multipartBoundary+"--", ""); |
| query = t.join("\r\n"); |
| } |
| }while(false); |
| |
| // kwArgs.Connection = "close"; |
| |
| var async = kwArgs["sync"] ? false : true; |
| |
| var preventCache = kwArgs["preventCache"] || |
| (this.preventCache == true && kwArgs["preventCache"] != false); |
| var useCache = kwArgs["useCache"] == true || |
| (this.useCache == true && kwArgs["useCache"] != false ); |
| |
| // preventCache is browser-level (add query string junk), useCache |
| // is for the local cache. If we say preventCache, then don't attempt |
| // to look in the cache, but if useCache is true, we still want to cache |
| // the response |
| if(!preventCache && useCache){ |
| var cachedHttp = getFromCache(url, query, kwArgs.method); |
| if(cachedHttp){ |
| doLoad(kwArgs, cachedHttp, url, query, false); |
| return; |
| } |
| } |
| |
| // much of this is from getText, but reproduced here because we need |
| // more flexibility |
| var http = dojo.hostenv.getXmlhttpObject(kwArgs); |
| var received = false; |
| |
| // build a handler function that calls back to the handler obj |
| if(async){ |
| var startTime = |
| // FIXME: setting up this callback handler leaks on IE!!! |
| this.inFlight.push({ |
| "req": kwArgs, |
| "http": http, |
| "url": url, |
| "query": query, |
| "useCache": useCache, |
| "startTime": kwArgs.timeoutSeconds ? (new Date()).getTime() : 0 |
| }); |
| this.startWatchingInFlight(); |
| }else{ |
| // block async callbacks until sync is in, needed in khtml, others? |
| _this._blockAsync = true; |
| } |
| |
| if(kwArgs.method.toLowerCase() == "post"){ |
| // FIXME: need to hack in more flexible Content-Type setting here! |
| if (!kwArgs.user) { |
| http.open("POST", url, async); |
| }else{ |
| http.open("POST", url, async, kwArgs.user, kwArgs.password); |
| } |
| setHeaders(http, kwArgs); |
| http.setRequestHeader("Content-Type", kwArgs.multipart ? ("multipart/form-data; boundary=" + this.multipartBoundary) : |
| (kwArgs.contentType || "application/x-www-form-urlencoded")); |
| try{ |
| http.send(query); |
| }catch(e){ |
| if(typeof http.abort == "function"){ |
| http.abort(); |
| } |
| doLoad(kwArgs, {status: 404}, url, query, useCache); |
| } |
| }else{ |
| var tmpUrl = url; |
| if(query != "") { |
| tmpUrl += (tmpUrl.indexOf("?") > -1 ? "&" : "?") + query; |
| } |
| if(preventCache) { |
| tmpUrl += (dojo.string.endsWithAny(tmpUrl, "?", "&") |
| ? "" : (tmpUrl.indexOf("?") > -1 ? "&" : "?")) + "dojo.preventCache=" + new Date().valueOf(); |
| } |
| if (!kwArgs.user) { |
| http.open(kwArgs.method.toUpperCase(), tmpUrl, async); |
| }else{ |
| http.open(kwArgs.method.toUpperCase(), tmpUrl, async, kwArgs.user, kwArgs.password); |
| } |
| setHeaders(http, kwArgs); |
| try { |
| http.send(null); |
| }catch(e) { |
| if(typeof http.abort == "function"){ |
| http.abort(); |
| } |
| doLoad(kwArgs, {status: 404}, url, query, useCache); |
| } |
| } |
| |
| if( !async ) { |
| doLoad(kwArgs, http, url, query, useCache); |
| _this._blockAsync = false; |
| } |
| |
| kwArgs.abort = function(){ |
| try{// khtml doesent reset readyState on abort, need this workaround |
| http._aborted = true; |
| }catch(e){/*squelsh*/} |
| return http.abort(); |
| } |
| |
| return; |
| } |
| dojo.io.transports.addTransport("XMLHTTPTransport"); |
| } |
| |
| } |
| |
| dojo.provide("dojo.io.cookie"); |
| |
| dojo.io.cookie.setCookie = function(/*String*/name, /*String*/value, |
| /*Number?*/days, /*String?*/path, |
| /*String?*/domain, /*boolean?*/secure){ |
| //summary: sets a cookie. |
| var expires = -1; |
| if((typeof days == "number")&&(days >= 0)){ |
| var d = new Date(); |
| d.setTime(d.getTime()+(days*24*60*60*1000)); |
| expires = d.toGMTString(); |
| } |
| value = escape(value); |
| document.cookie = name + "=" + value + ";" |
| + (expires != -1 ? " expires=" + expires + ";" : "") |
| + (path ? "path=" + path : "") |
| + (domain ? "; domain=" + domain : "") |
| + (secure ? "; secure" : ""); |
| } |
| |
| dojo.io.cookie.set = dojo.io.cookie.setCookie; |
| |
| dojo.io.cookie.getCookie = function(/*String*/name){ |
| //summary: Gets a cookie with the given name. |
| |
| // FIXME: Which cookie should we return? |
| // If there are cookies set for different sub domains in the current |
| // scope there could be more than one cookie with the same name. |
| // I think taking the last one in the list takes the one from the |
| // deepest subdomain, which is what we're doing here. |
| var idx = document.cookie.lastIndexOf(name+'='); |
| if(idx == -1) { return null; } |
| var value = document.cookie.substring(idx+name.length+1); |
| var end = value.indexOf(';'); |
| if(end == -1) { end = value.length; } |
| value = value.substring(0, end); |
| value = unescape(value); |
| return value; //String |
| } |
| |
| dojo.io.cookie.get = dojo.io.cookie.getCookie; |
| |
| dojo.io.cookie.deleteCookie = function(/*String*/name){ |
| //summary: Deletes a cookie with the given name. |
| dojo.io.cookie.setCookie(name, "-", 0); |
| } |
| |
| dojo.io.cookie.setObjectCookie = function( /*String*/name, /*Object*/obj, |
| /*Number?*/days, /*String?*/path, |
| /*String?*/domain, /*boolean?*/secure, |
| /*boolean?*/clearCurrent){ |
| //summary: Takes an object, serializes it to a cookie value, and either |
| //sets a cookie with the serialized value. |
| //description: If clearCurrent is true, then any current cookie value |
| //for this object will be replaced with the the new serialized object value. |
| //If clearCurrent is false, then the existing cookie value will be modified |
| //with any changes from the new object value. |
| //Objects must be simple name/value pairs where the value is either a string |
| //or a number. Any other value will be ignored. |
| if(arguments.length == 5){ // for backwards compat |
| clearCurrent = domain; |
| domain = null; |
| secure = null; |
| } |
| var pairs = [], cookie, value = ""; |
| if(!clearCurrent){ |
| cookie = dojo.io.cookie.getObjectCookie(name); |
| } |
| if(days >= 0){ |
| if(!cookie){ cookie = {}; } |
| for(var prop in obj){ |
| if(obj[prop] == null){ |
| delete cookie[prop]; |
| }else if((typeof obj[prop] == "string")||(typeof obj[prop] == "number")){ |
| cookie[prop] = obj[prop]; |
| } |
| } |
| prop = null; |
| for(var prop in cookie){ |
| pairs.push(escape(prop) + "=" + escape(cookie[prop])); |
| } |
| value = pairs.join("&"); |
| } |
| dojo.io.cookie.setCookie(name, value, days, path, domain, secure); |
| } |
| |
| dojo.io.cookie.getObjectCookie = function(/*String*/name){ |
| //summary: Gets an object value for the given cookie name. The complement of |
| //dojo.io.cookie.setObjectCookie(). |
| var values = null, cookie = dojo.io.cookie.getCookie(name); |
| if(cookie){ |
| values = {}; |
| var pairs = cookie.split("&"); |
| for(var i = 0; i < pairs.length; i++){ |
| var pair = pairs[i].split("="); |
| var value = pair[1]; |
| if( isNaN(value) ){ value = unescape(pair[1]); } |
| values[ unescape(pair[0]) ] = value; |
| } |
| } |
| return values; |
| } |
| |
| dojo.io.cookie.isSupported = function(){ |
| //summary: Tests the browser to see if cookies are enabled. |
| if(typeof navigator.cookieEnabled != "boolean"){ |
| dojo.io.cookie.setCookie("__TestingYourBrowserForCookieSupport__", |
| "CookiesAllowed", 90, null); |
| var cookieVal = dojo.io.cookie.getCookie("__TestingYourBrowserForCookieSupport__"); |
| navigator.cookieEnabled = (cookieVal == "CookiesAllowed"); |
| if(navigator.cookieEnabled){ |
| // FIXME: should we leave this around? |
| this.deleteCookie("__TestingYourBrowserForCookieSupport__"); |
| } |
| } |
| return navigator.cookieEnabled; //boolean |
| } |
| |
| // need to leave this in for backwards-compat from 0.1 for when it gets pulled in by dojo.io.* |
| if(!dojo.io.cookies){ dojo.io.cookies = dojo.io.cookie; } |
| |
| dojo.kwCompoundRequire({ |
| common: ["dojo.io.common"], |
| rhino: ["dojo.io.RhinoIO"], |
| browser: ["dojo.io.BrowserIO", "dojo.io.cookie"], |
| dashboard: ["dojo.io.BrowserIO", "dojo.io.cookie"] |
| }); |
| dojo.provide("dojo.io.*"); |
| |
| dojo.provide("dojo.event.common"); |
| |
| |
| |
| |
| |
| // TODO: connection filter functions |
| // these are functions that accept a method invocation (like around |
| // advice) and return a boolean based on it. That value determines |
| // whether or not the connection proceeds. It could "feel" like around |
| // advice for those who know what it is (calling proceed() or not), |
| // but I think presenting it as a "filter" and/or calling it with the |
| // function args and not the MethodInvocation might make it more |
| // palletable to "normal" users than around-advice currently is |
| // TODO: execution scope mangling |
| // YUI's event facility by default executes listeners in the context |
| // of the source object. This is very odd, but should probably be |
| // supported as an option (both for the source and for the dest). It |
| // can be thought of as a connection-specific hitch(). |
| // TODO: more resiliency for 4+ arguments to connect() |
| |
| dojo.event = new function(){ |
| this._canTimeout = dojo.lang.isFunction(dj_global["setTimeout"])||dojo.lang.isAlien(dj_global["setTimeout"]); |
| |
| // FIXME: where should we put this method (not here!)? |
| function interpolateArgs(args, searchForNames){ |
| var dl = dojo.lang; |
| var ao = { |
| srcObj: dj_global, |
| srcFunc: null, |
| adviceObj: dj_global, |
| adviceFunc: null, |
| aroundObj: null, |
| aroundFunc: null, |
| adviceType: (args.length>2) ? args[0] : "after", |
| precedence: "last", |
| once: false, |
| delay: null, |
| rate: 0, |
| adviceMsg: false, |
| maxCalls: -1 |
| }; |
| |
| switch(args.length){ |
| case 0: return; |
| case 1: return; |
| case 2: |
| ao.srcFunc = args[0]; |
| ao.adviceFunc = args[1]; |
| break; |
| case 3: |
| if((dl.isObject(args[0]))&&(dl.isString(args[1]))&&(dl.isString(args[2]))){ |
| ao.adviceType = "after"; |
| ao.srcObj = args[0]; |
| ao.srcFunc = args[1]; |
| ao.adviceFunc = args[2]; |
| }else if((dl.isString(args[1]))&&(dl.isString(args[2]))){ |
| ao.srcFunc = args[1]; |
| ao.adviceFunc = args[2]; |
| }else if((dl.isObject(args[0]))&&(dl.isString(args[1]))&&(dl.isFunction(args[2]))){ |
| ao.adviceType = "after"; |
| ao.srcObj = args[0]; |
| ao.srcFunc = args[1]; |
| var tmpName = dl.nameAnonFunc(args[2], ao.adviceObj, searchForNames); |
| ao.adviceFunc = tmpName; |
| }else if((dl.isFunction(args[0]))&&(dl.isObject(args[1]))&&(dl.isString(args[2]))){ |
| ao.adviceType = "after"; |
| ao.srcObj = dj_global; |
| var tmpName = dl.nameAnonFunc(args[0], ao.srcObj, searchForNames); |
| ao.srcFunc = tmpName; |
| ao.adviceObj = args[1]; |
| ao.adviceFunc = args[2]; |
| } |
| break; |
| case 4: |
| if((dl.isObject(args[0]))&&(dl.isObject(args[2]))){ |
| // we can assume that we've got an old-style "connect" from |
| // the sigslot school of event attachment. We therefore |
| // assume after-advice. |
| ao.adviceType = "after"; |
| ao.srcObj = args[0]; |
| ao.srcFunc = args[1]; |
| ao.adviceObj = args[2]; |
| ao.adviceFunc = args[3]; |
| }else if((dl.isString(args[0]))&&(dl.isString(args[1]))&&(dl.isObject(args[2]))){ |
| ao.adviceType = args[0]; |
| ao.srcObj = dj_global; |
| ao.srcFunc = args[1]; |
| ao.adviceObj = args[2]; |
| ao.adviceFunc = args[3]; |
| }else if((dl.isString(args[0]))&&(dl.isFunction(args[1]))&&(dl.isObject(args[2]))){ |
| ao.adviceType = args[0]; |
| ao.srcObj = dj_global; |
| var tmpName = dl.nameAnonFunc(args[1], dj_global, searchForNames); |
| ao.srcFunc = tmpName; |
| ao.adviceObj = args[2]; |
| ao.adviceFunc = args[3]; |
| }else if((dl.isString(args[0]))&&(dl.isObject(args[1]))&&(dl.isString(args[2]))&&(dl.isFunction(args[3]))){ |
| ao.srcObj = args[1]; |
| ao.srcFunc = args[2]; |
| var tmpName = dl.nameAnonFunc(args[3], dj_global, searchForNames); |
| ao.adviceObj = dj_global; |
| ao.adviceFunc = tmpName; |
| }else if(dl.isObject(args[1])){ |
| ao.srcObj = args[1]; |
| ao.srcFunc = args[2]; |
| ao.adviceObj = dj_global; |
| ao.adviceFunc = args[3]; |
| }else if(dl.isObject(args[2])){ |
| ao.srcObj = dj_global; |
| ao.srcFunc = args[1]; |
| ao.adviceObj = args[2]; |
| ao.adviceFunc = args[3]; |
| }else{ |
| ao.srcObj = ao.adviceObj = ao.aroundObj = dj_global; |
| ao.srcFunc = args[1]; |
| ao.adviceFunc = args[2]; |
| ao.aroundFunc = args[3]; |
| } |
| break; |
| case 6: |
| ao.srcObj = args[1]; |
| ao.srcFunc = args[2]; |
| ao.adviceObj = args[3] |
| ao.adviceFunc = args[4]; |
| ao.aroundFunc = args[5]; |
| ao.aroundObj = dj_global; |
| break; |
| default: |
| ao.srcObj = args[1]; |
| ao.srcFunc = args[2]; |
| ao.adviceObj = args[3] |
| ao.adviceFunc = args[4]; |
| ao.aroundObj = args[5]; |
| ao.aroundFunc = args[6]; |
| ao.once = args[7]; |
| ao.delay = args[8]; |
| ao.rate = args[9]; |
| ao.adviceMsg = args[10]; |
| ao.maxCalls = (!isNaN(parseInt(args[11]))) ? args[11] : -1; |
| break; |
| } |
| |
| if(dl.isFunction(ao.aroundFunc)){ |
| var tmpName = dl.nameAnonFunc(ao.aroundFunc, ao.aroundObj, searchForNames); |
| ao.aroundFunc = tmpName; |
| } |
| |
| if(dl.isFunction(ao.srcFunc)){ |
| ao.srcFunc = dl.getNameInObj(ao.srcObj, ao.srcFunc); |
| } |
| |
| if(dl.isFunction(ao.adviceFunc)){ |
| ao.adviceFunc = dl.getNameInObj(ao.adviceObj, ao.adviceFunc); |
| } |
| |
| if((ao.aroundObj)&&(dl.isFunction(ao.aroundFunc))){ |
| ao.aroundFunc = dl.getNameInObj(ao.aroundObj, ao.aroundFunc); |
| } |
| |
| if(!ao.srcObj){ |
| dojo.raise("bad srcObj for srcFunc: "+ao.srcFunc); |
| } |
| if(!ao.adviceObj){ |
| dojo.raise("bad adviceObj for adviceFunc: "+ao.adviceFunc); |
| } |
| |
| if(!ao.adviceFunc){ |
| dojo.debug("bad adviceFunc for srcFunc: "+ao.srcFunc); |
| dojo.debugShallow(ao); |
| } |
| |
| return ao; |
| } |
| |
| this.connect = function(/*...*/){ |
| // summary: |
| // dojo.event.connect is the glue that holds most Dojo-based |
| // applications together. Most combinations of arguments are |
| // supported, with the connect() method attempting to disambiguate |
| // the implied types of positional parameters. The following will |
| // all work: |
| // dojo.event.connect("globalFunctionName1", "globalFunctionName2"); |
| // dojo.event.connect(functionReference1, functionReference2); |
| // dojo.event.connect("globalFunctionName1", functionReference2); |
| // dojo.event.connect(functionReference1, "globalFunctionName2"); |
| // dojo.event.connect(scope1, "functionName1", "globalFunctionName2"); |
| // dojo.event.connect("globalFunctionName1", scope2, "functionName2"); |
| // dojo.event.connect(scope1, "functionName1", scope2, "functionName2"); |
| // dojo.event.connect("after", scope1, "functionName1", scope2, "functionName2"); |
| // dojo.event.connect("before", scope1, "functionName1", scope2, "functionName2"); |
| // dojo.event.connect("around", scope1, "functionName1", |
| // scope2, "functionName2", |
| // aroundFunctionReference); |
| // dojo.event.connect("around", scope1, "functionName1", |
| // scope2, "functionName2", |
| // scope3, "aroundFunctionName"); |
| // dojo.event.connect("before-around", scope1, "functionName1", |
| // scope2, "functionName2", |
| // aroundFunctionReference); |
| // dojo.event.connect("after-around", scope1, "functionName1", |
| // scope2, "functionName2", |
| // aroundFunctionReference); |
| // dojo.event.connect("after-around", scope1, "functionName1", |
| // scope2, "functionName2", |
| // scope3, "aroundFunctionName"); |
| // dojo.event.connect("around", scope1, "functionName1", |
| // scope2, "functionName2", |
| // scope3, "aroundFunctionName", true, 30); |
| // dojo.event.connect("around", scope1, "functionName1", |
| // scope2, "functionName2", |
| // scope3, "aroundFunctionName", null, null, 10); |
| // adviceType: |
| // Optional. String. One of "before", "after", "around", |
| // "before-around", or "after-around". FIXME |
| // srcObj: |
| // the scope in which to locate/execute the named srcFunc. Along |
| // with srcFunc, this creates a way to dereference the function to |
| // call. So if the function in question is "foo.bar", the |
| // srcObj/srcFunc pair would be foo and "bar", where "bar" is a |
| // string and foo is an object reference. |
| // srcFunc: |
| // the name of the function to connect to. When it is executed, |
| // the listener being registered with this call will be called. |
| // The adviceType defines the call order between the source and |
| // the target functions. |
| // adviceObj: |
| // the scope in which to locate/execute the named adviceFunc. |
| // adviceFunc: |
| // the name of the function being conected to srcObj.srcFunc |
| // aroundObj: |
| // the scope in which to locate/execute the named aroundFunc. |
| // aroundFunc: |
| // the name of, or a reference to, the function that will be used |
| // to mediate the advice call. Around advice requires a special |
| // unary function that will be passed a "MethodInvocation" object. |
| // These objects have several important properties, namely: |
| // - args |
| // a mutable array of arguments to be passed into the |
| // wrapped function |
| // - proceed |
| // a function that "continues" the invocation. The result |
| // of this function is the return of the wrapped function. |
| // You can then manipulate this return before passing it |
| // back out (or take further action based on it). |
| // once: |
| // boolean that determines whether or not this connect() will |
| // create a new connection if an identical connect() has already |
| // been made. Defaults to "false". |
| // delay: |
| // an optional delay (in ms), as an integer, for dispatch of a |
| // listener after the source has been fired. |
| // rate: |
| // an optional rate throttling parameter (integer, in ms). When |
| // specified, this particular connection will not fire more than |
| // once in the interval specified by the rate |
| // adviceMsg: |
| // boolean. Should the listener have all the parameters passed in |
| // as a single argument? |
| |
| /* |
| ao.adviceType = args[0]; |
| ao.srcObj = args[1]; |
| ao.srcFunc = args[2]; |
| ao.adviceObj = args[3] |
| ao.adviceFunc = args[4]; |
| ao.aroundObj = args[5]; |
| ao.aroundFunc = args[6]; |
| ao.once = args[7]; |
| ao.delay = args[8]; |
| ao.rate = args[9]; |
| ao.adviceMsg = args[10]; |
| ao.maxCalls = args[11]; |
| */ |
| if(arguments.length == 1){ |
| var ao = arguments[0]; |
| }else{ |
| var ao = interpolateArgs(arguments, true); |
| } |
| if(dojo.lang.isString(ao.srcFunc) && (ao.srcFunc.toLowerCase() == "onkey") ){ |
| if(dojo.render.html.ie){ |
| ao.srcFunc = "onkeydown"; |
| this.connect(ao); |
| } |
| ao.srcFunc = "onkeypress"; |
| } |
| |
| if(dojo.lang.isArray(ao.srcObj) && ao.srcObj!=""){ |
| var tmpAO = {}; |
| for(var x in ao){ |
| tmpAO[x] = ao[x]; |
| } |
| var mjps = []; |
| dojo.lang.forEach(ao.srcObj, function(src){ |
| if((dojo.render.html.capable)&&(dojo.lang.isString(src))){ |
| src = dojo.byId(src); |
| // dojo.debug(src); |
| } |
| tmpAO.srcObj = src; |
| // dojo.debug(tmpAO.srcObj, tmpAO.srcFunc); |
| // dojo.debug(tmpAO.adviceObj, tmpAO.adviceFunc); |
| mjps.push(dojo.event.connect.call(dojo.event, tmpAO)); |
| }); |
| return mjps; |
| } |
| |
| // FIXME: just doing a "getForMethod()" seems to be enough to put this into infinite recursion!! |
| var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc); |
| if(ao.adviceFunc){ |
| var mjp2 = dojo.event.MethodJoinPoint.getForMethod(ao.adviceObj, ao.adviceFunc); |
| } |
| |
| mjp.kwAddAdvice(ao); |
| |
| // advanced users might want to fsck w/ the join point manually |
| return mjp; // a MethodJoinPoint object |
| } |
| |
| this.log = function(/*object or funcName*/ a1, /*funcName*/ a2){ |
| // summary: |
| // a function that will wrap and log all calls to the specified |
| // a1.a2() function. If only a1 is passed, it'll be used as a |
| // function or function name on the global context. Logging will |
| // be sent to dojo.debug |
| // a1: |
| // if a2 is passed, this should be an object. If not, it can be a |
| // function or function name. |
| // a2: |
| // a function name |
| var kwArgs; |
| if((arguments.length == 1)&&(typeof a1 == "object")){ |
| kwArgs = a1; |
| }else{ |
| kwArgs = { |
| srcObj: a1, |
| srcFunc: a2 |
| }; |
| } |
| kwArgs.adviceFunc = function(){ |
| var argsStr = []; |
| for(var x=0; x<arguments.length; x++){ |
| argsStr.push(arguments[x]); |
| } |
| dojo.debug("("+kwArgs.srcObj+")."+kwArgs.srcFunc, ":", argsStr.join(", ")); |
| }; |
| this.kwConnect(kwArgs); |
| } |
| |
| this.connectBefore = function(){ |
| // summary: |
| // takes the same parameters as dojo.event.connect(), except that |
| // the advice type will always be "before" |
| var args = ["before"]; |
| for(var i = 0; i < arguments.length; i++){ args.push(arguments[i]); } |
| return this.connect.apply(this, args); // a MethodJoinPoint object |
| } |
| |
| this.connectAround = function(){ |
| // summary: |
| // takes the same parameters as dojo.event.connect(), except that |
| // the advice type will always be "around" |
| var args = ["around"]; |
| for(var i = 0; i < arguments.length; i++){ args.push(arguments[i]); } |
| return this.connect.apply(this, args); // a MethodJoinPoint object |
| } |
| |
| this.connectOnce = function(){ |
| // summary: |
| // takes the same parameters as dojo.event.connect(), except that |
| // the "once" flag will always be set to "true" |
| var ao = interpolateArgs(arguments, true); |
| ao.once = true; |
| return this.connect(ao); // a MethodJoinPoint object |
| } |
| |
| this.connectRunOnce = function(){ |
| // summary: |
| // takes the same parameters as dojo.event.connect(), except that |
| // the "maxCalls" flag will always be set to 1 |
| var ao = interpolateArgs(arguments, true); |
| ao.maxCalls = 1; |
| return this.connect(ao); // a MethodJoinPoint object |
| } |
| |
| this._kwConnectImpl = function(kwArgs, disconnect){ |
| var fn = (disconnect) ? "disconnect" : "connect"; |
| if(typeof kwArgs["srcFunc"] == "function"){ |
| kwArgs.srcObj = kwArgs["srcObj"]||dj_global; |
| var tmpName = dojo.lang.nameAnonFunc(kwArgs.srcFunc, kwArgs.srcObj, true); |
| kwArgs.srcFunc = tmpName; |
| } |
| if(typeof kwArgs["adviceFunc"] == "function"){ |
| kwArgs.adviceObj = kwArgs["adviceObj"]||dj_global; |
| var tmpName = dojo.lang.nameAnonFunc(kwArgs.adviceFunc, kwArgs.adviceObj, true); |
| kwArgs.adviceFunc = tmpName; |
| } |
| kwArgs.srcObj = kwArgs["srcObj"]||dj_global; |
| kwArgs.adviceObj = kwArgs["adviceObj"]||kwArgs["targetObj"]||dj_global; |
| kwArgs.adviceFunc = kwArgs["adviceFunc"]||kwArgs["targetFunc"]; |
| // pass kwargs to avoid unrolling/repacking |
| return dojo.event[fn](kwArgs); |
| } |
| |
| this.kwConnect = function(/*Object*/ kwArgs){ |
| // summary: |
| // A version of dojo.event.connect() that takes a map of named |
| // parameters instead of the positional parameters that |
| // dojo.event.connect() uses. For many advanced connection types, |
| // this can be a much more readable (and potentially faster) |
| // alternative. |
| // kwArgs: |
| // An object that can have the following properties: |
| // - adviceType |
| // - srcObj |
| // - srcFunc |
| // - adviceObj |
| // - adviceFunc |
| // - aroundObj |
| // - aroundFunc |
| // - once |
| // - delay |
| // - rate |
| // - adviceMsg |
| // As with connect, only srcFunc and adviceFunc are generally |
| // required |
| |
| return this._kwConnectImpl(kwArgs, false); // a MethodJoinPoint object |
| |
| } |
| |
| this.disconnect = function(){ |
| // summary: |
| // Takes the same parameters as dojo.event.connect() but destroys |
| // an existing connection instead of building a new one. For |
| // multiple identical connections, multiple disconnect() calls |
| // will unroll one each time it's called. |
| if(arguments.length == 1){ |
| var ao = arguments[0]; |
| }else{ |
| var ao = interpolateArgs(arguments, true); |
| } |
| if(!ao.adviceFunc){ return; } // nothing to disconnect |
| if(dojo.lang.isString(ao.srcFunc) && (ao.srcFunc.toLowerCase() == "onkey") ){ |
| if(dojo.render.html.ie){ |
| ao.srcFunc = "onkeydown"; |
| this.disconnect(ao); |
| } |
| ao.srcFunc = "onkeypress"; |
| } |
| if(!ao.srcObj[ao.srcFunc]){ return null; } // prevent un-necessaray joinpoint creation |
| var mjp = dojo.event.MethodJoinPoint.getForMethod(ao.srcObj, ao.srcFunc, true); |
| mjp.removeAdvice(ao.adviceObj, ao.adviceFunc, ao.adviceType, ao.once); // a MethodJoinPoint object |
| return mjp; |
| } |
| |
| this.kwDisconnect = function(kwArgs){ |
| // summary: |
| // Takes the same parameters as dojo.event.kwConnect() but |
| // destroys an existing connection instead of building a new one. |
| return this._kwConnectImpl(kwArgs, true); |
| } |
| } |
| |
| // exactly one of these is created whenever a method with a joint point is run, |
| // if there is at least one 'around' advice. |
| dojo.event.MethodInvocation = function(/*dojo.event.MethodJoinPoint*/join_point, /*Object*/obj, /*Array*/args){ |
| // summary: |
| // a class the models the call into a function. This is used under the |
| // covers for all method invocations on both ends of a |
| // connect()-wrapped function dispatch. This allows us to "pickle" |
| // calls, such as in the case of around advice. |
| // join_point: |
| // a dojo.event.MethodJoinPoint object that represents a connection |
| // obj: |
| // the scope the call will execute in |
| // args: |
| // an array of parameters that will get passed to the callee |
| this.jp_ = join_point; |
| this.object = obj; |
| this.args = []; |
| // make sure we don't lock into a mutable object which can change under us. |
| // It's ok if the individual items change, though. |
| for(var x=0; x<args.length; x++){ |
| this.args[x] = args[x]; |
| } |
| // the index of the 'around' that is currently being executed. |
| this.around_index = -1; |
| } |
| |
| dojo.event.MethodInvocation.prototype.proceed = function(){ |
| // summary: |
| // proceed with the method call that's represented by this invocation |
| // object |
| this.around_index++; |
| if(this.around_index >= this.jp_.around.length){ |
| return this.jp_.object[this.jp_.methodname].apply(this.jp_.object, this.args); |
| // return this.jp_.run_before_after(this.object, this.args); |
| }else{ |
| var ti = this.jp_.around[this.around_index]; |
| var mobj = ti[0]||dj_global; |
| var meth = ti[1]; |
| return mobj[meth].call(mobj, this); |
| } |
| } |
| |
| |
| dojo.event.MethodJoinPoint = function(/*Object*/obj, /*String*/funcName){ |
| this.object = obj||dj_global; |
| this.methodname = funcName; |
| this.methodfunc = this.object[funcName]; |
| this.squelch = false; |
| // this.before = []; |
| // this.after = []; |
| // this.around = []; |
| } |
| |
| dojo.event.MethodJoinPoint.getForMethod = function(/*Object*/obj, /*String*/funcName){ |
| // summary: |
| // "static" class function for returning a MethodJoinPoint from a |
| // scoped function. If one doesn't exist, one is created. |
| // obj: |
| // the scope to search for the function in |
| // funcName: |
| // the name of the function to return a MethodJoinPoint for |
| if(!obj){ obj = dj_global; } |
| var ofn = obj[funcName]; |
| if(!ofn){ |
| // supply a do-nothing method implementation |
| ofn = obj[funcName] = function(){}; |
| if(!obj[funcName]){ |
| // e.g. cannot add to inbuilt objects in IE6 |
| dojo.raise("Cannot set do-nothing method on that object "+funcName); |
| } |
| }else if((typeof ofn != "function")&&(!dojo.lang.isFunction(ofn))&&(!dojo.lang.isAlien(ofn))){ |
| // FIXME: should we throw an exception here instead? |
| return null; |
| } |
| // we hide our joinpoint instance in obj[funcName + '$joinpoint'] |
| var jpname = funcName + "$joinpoint"; |
| var jpfuncname = funcName + "$joinpoint$method"; |
| var joinpoint = obj[jpname]; |
| if(!joinpoint){ |
| var isNode = false; |
| if(dojo.event["browser"]){ |
| if( (obj["attachEvent"])|| |
| (obj["nodeType"])|| |
| (obj["addEventListener"]) ){ |
| isNode = true; |
| dojo.event.browser.addClobberNodeAttrs(obj, [jpname, jpfuncname, funcName]); |
| } |
| } |
| var origArity = ofn.length; |
| obj[jpfuncname] = ofn; |
| // joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, funcName); |
| joinpoint = obj[jpname] = new dojo.event.MethodJoinPoint(obj, jpfuncname); |
| |
| if(!isNode){ |
| obj[funcName] = function(){ |
| // var args = []; |
| // for(var x=0; x<arguments.length; x++){ |
| // args.push(arguments[x]); |
| // } |
| // return joinpoint.run.apply(joinpoint, args); |
| return joinpoint.run.apply(joinpoint, arguments); |
| } |
| }else{ |
| obj[funcName] = function(){ |
| var args = []; |
| |
| if(!arguments.length){ |
| var evt = null; |
| try{ |
| if(obj.ownerDocument){ |
| evt = obj.ownerDocument.parentWindow.event; |
| }else if(obj.documentElement){ |
| evt = obj.documentElement.ownerDocument.parentWindow.event; |
| }else if(obj.event){ //obj is a window |
| evt = obj.event; |
| }else{ |
| evt = window.event; |
| } |
| }catch(e){ |
| evt = window.event; |
| } |
| |
| if(evt){ |
| args.push(dojo.event.browser.fixEvent(evt, this)); |
| } |
| }else{ |
| for(var x=0; x<arguments.length; x++){ |
| if((x==0)&&(dojo.event.browser.isEvent(arguments[x]))){ |
| args.push(dojo.event.browser.fixEvent(arguments[x], this)); |
| }else{ |
| args.push(arguments[x]); |
| } |
| } |
| } |
| // return joinpoint.run.apply(joinpoint, arguments); |
| return joinpoint.run.apply(joinpoint, args); |
| } |
| } |
| obj[funcName].__preJoinArity = origArity; |
| } |
| return joinpoint; // dojo.event.MethodJoinPoint |
| } |
| |
| dojo.lang.extend(dojo.event.MethodJoinPoint, { |
| squelch: false, |
| |
| unintercept: function(){ |
| // summary: |
| // destroy the connection to all listeners that may have been |
| // registered on this joinpoint |
| this.object[this.methodname] = this.methodfunc; |
| this.before = []; |
| this.after = []; |
| this.around = []; |
| }, |
| |
| disconnect: dojo.lang.forward("unintercept"), |
| |
| run: function(){ |
| // summary: |
| // execute the connection represented by this join point. The |
| // arguments passed to run() will be passed to the function and |
| // its listeners. |
| var obj = this.object||dj_global; |
| var args = arguments; |
| |
| // optimization. We only compute once the array version of the arguments |
| // pseudo-arr in order to prevent building it each time advice is unrolled. |
| var aargs = []; |
| for(var x=0; x<args.length; x++){ |
| aargs[x] = args[x]; |
| } |
| |
| var unrollAdvice = function(marr){ |
| if(!marr){ |
| dojo.debug("Null argument to unrollAdvice()"); |
| return; |
| } |
| |
| var callObj = marr[0]||dj_global; |
| var callFunc = marr[1]; |
| |
| if(!callObj[callFunc]){ |
| dojo.raise("function \"" + callFunc + "\" does not exist on \"" + callObj + "\""); |
| } |
| |
| var aroundObj = marr[2]||dj_global; |
| var aroundFunc = marr[3]; |
| var msg = marr[6]; |
| var maxCount = marr[7]; |
| if(maxCount > -1){ |
| if(maxCount == 0){ |
| return; |
| } |
| marr[7]--; |
| } |
| var undef; |
| |
| var to = { |
| args: [], |
| jp_: this, |
| object: obj, |
| proceed: function(){ |
| return callObj[callFunc].apply(callObj, to.args); |
| } |
| }; |
| to.args = aargs; |
| |
| var delay = parseInt(marr[4]); |
| var hasDelay = ((!isNaN(delay))&&(marr[4]!==null)&&(typeof marr[4] != "undefined")); |
| if(marr[5]){ |
| var rate = parseInt(marr[5]); |
| var cur = new Date(); |
| var timerSet = false; |
| if((marr["last"])&&((cur-marr.last)<=rate)){ |
| if(dojo.event._canTimeout){ |
| if(marr["delayTimer"]){ |
| clearTimeout(marr.delayTimer); |
| } |
| var tod = parseInt(rate*2); // is rate*2 naive? |
| var mcpy = dojo.lang.shallowCopy(marr); |
| marr.delayTimer = setTimeout(function(){ |
| // FIXME: on IE at least, event objects from the |
| // browser can go out of scope. How (or should?) we |
| // deal with it? |
| mcpy[5] = 0; |
| unrollAdvice(mcpy); |
| }, tod); |
| } |
| return; |
| }else{ |
| marr.last = cur; |
| } |
| } |
| |
| // FIXME: need to enforce rates for a connection here! |
| |
| if(aroundFunc){ |
| // NOTE: around advice can't delay since we might otherwise depend |
| // on execution order! |
| aroundObj[aroundFunc].call(aroundObj, to); |
| }else{ |
| // var tmjp = dojo.event.MethodJoinPoint.getForMethod(obj, methname); |
| if((hasDelay)&&((dojo.render.html)||(dojo.render.svg))){ // FIXME: the render checks are grotty! |
| dj_global["setTimeout"](function(){ |
| if(msg){ |
| callObj[callFunc].call(callObj, to); |
| }else{ |
| callObj[callFunc].apply(callObj, args); |
| } |
| }, delay); |
| }else{ // many environments can't support delay! |
| if(msg){ |
| callObj[callFunc].call(callObj, to); |
| }else{ |
| callObj[callFunc].apply(callObj, args); |
| } |
| } |
| } |
| }; |
| |
| var unRollSquelch = function(){ |
| if(this.squelch){ |
| try{ |
| return unrollAdvice.apply(this, arguments); |
| }catch(e){ |
| dojo.debug(e); |
| } |
| }else{ |
| return unrollAdvice.apply(this, arguments); |
| } |
| }; |
| |
| if((this["before"])&&(this.before.length>0)){ |
| // pass a cloned array, if this event disconnects this event forEach on this.before wont work |
| dojo.lang.forEach(this.before.concat(new Array()), unRollSquelch); |
| } |
| |
| var result; |
| try{ |
| if((this["around"])&&(this.around.length>0)){ |
| var mi = new dojo.event.MethodInvocation(this, obj, args); |
| result = mi.proceed(); |
| }else if(this.methodfunc){ |
| result = this.object[this.methodname].apply(this.object, args); |
| } |
| }catch(e){ |
| if(!this.squelch){ |
| dojo.debug(e,"when calling",this.methodname,"on",this.object,"with arguments",args); |
| dojo.raise(e); |
| } |
| } |
| |
| if((this["after"])&&(this.after.length>0)){ |
| // see comment on this.before above |
| dojo.lang.forEach(this.after.concat(new Array()), unRollSquelch); |
| } |
| |
| return (this.methodfunc) ? result : null; |
| }, |
| |
| getArr: function(/*String*/kind){ |
| // summary: return a list of listeners of the past "kind" |
| // kind: |
| // can be one of: "before", "after", "around", "before-around", or |
| // "after-around" |
| var type = "after"; |
| // FIXME: we should be able to do this through props or Array.in() |
| if((typeof kind == "string")&&(kind.indexOf("before")!=-1)){ |
| type = "before"; |
| }else if(kind=="around"){ |
| type = "around"; |
| } |
| if(!this[type]){ this[type] = []; } |
| return this[type]; // Array |
| }, |
| |
| kwAddAdvice: function(/*Object*/args){ |
| // summary: |
| // adds advice to the joinpoint with arguments in a map |
| // args: |
| // An object that can have the following properties: |
| // - adviceType |
| // - adviceObj |
| // - adviceFunc |
| // - aroundObj |
| // - aroundFunc |
| // - once |
| // - delay |
| // - rate |
| // - adviceMsg |
| // - maxCalls |
| this.addAdvice( args["adviceObj"], args["adviceFunc"], |
| args["aroundObj"], args["aroundFunc"], |
| args["adviceType"], args["precedence"], |
| args["once"], args["delay"], args["rate"], |
| args["adviceMsg"], args["maxCalls"]); |
| }, |
| |
| addAdvice: function( thisAdviceObj, thisAdvice, |
| thisAroundObj, thisAround, |
| adviceType, precedence, |
| once, delay, rate, asMessage, |
| maxCalls){ |
| // summary: |
| // add advice to this joinpoint using positional parameters |
| // thisAdviceObj: |
| // the scope in which to locate/execute the named adviceFunc. |
| // thisAdviceFunc: |
| // the name of the function being conected |
| // thisAroundObj: |
| // the scope in which to locate/execute the named aroundFunc. |
| // thisAroundFunc: |
| // the name of the function that will be used to mediate the |
| // advice call. |
| // adviceType: |
| // Optional. String. One of "before", "after", "around", |
| // "before-around", or "after-around". FIXME |
| // once: |
| // boolean that determines whether or not this advice will create |
| // a new connection if an identical advice set has already been |
| // provided. Defaults to "false". |
| // delay: |
| // an optional delay (in ms), as an integer, for dispatch of a |
| // listener after the source has been fired. |
| // rate: |
| // an optional rate throttling parameter (integer, in ms). When |
| // specified, this particular connection will not fire more than |
| // once in the interval specified by the rate |
| // adviceMsg: |
| // boolean. Should the listener have all the parameters passed in |
| // as a single argument? |
| // maxCalls: |
| // Integer. The maximum number of times this connection can be |
| // used before being auto-disconnected. -1 signals that the |
| // connection should never be disconnected. |
| var arr = this.getArr(adviceType); |
| if(!arr){ |
| dojo.raise("bad this: " + this); |
| } |
| |
| var ao = [thisAdviceObj, thisAdvice, thisAroundObj, thisAround, delay, rate, asMessage, maxCalls]; |
| |
| if(once){ |
| if(this.hasAdvice(thisAdviceObj, thisAdvice, adviceType, arr) >= 0){ |
| return; |
| } |
| } |
| |
| if(precedence == "first"){ |
| arr.unshift(ao); |
| }else{ |
| arr.push(ao); |
| } |
| }, |
| |
| hasAdvice: function(thisAdviceObj, thisAdvice, adviceType, arr){ |
| // summary: |
| // returns the array index of the first existing connection |
| // betweened the passed advice and this joinpoint. Will be -1 if |
| // none exists. |
| // thisAdviceObj: |
| // the scope in which to locate/execute the named adviceFunc. |
| // thisAdviceFunc: |
| // the name of the function being conected |
| // adviceType: |
| // Optional. String. One of "before", "after", "around", |
| // "before-around", or "after-around". FIXME |
| // arr: |
| // Optional. The list of advices to search. Will be found via |
| // adviceType if not passed |
| if(!arr){ arr = this.getArr(adviceType); } |
| var ind = -1; |
| for(var x=0; x<arr.length; x++){ |
| var aao = (typeof thisAdvice == "object") ? (new String(thisAdvice)).toString() : thisAdvice; |
| var a1o = (typeof arr[x][1] == "object") ? (new String(arr[x][1])).toString() : arr[x][1]; |
| if((arr[x][0] == thisAdviceObj)&&(a1o == aao)){ |
| ind = x; |
| } |
| } |
| return ind; // Integer |
| }, |
| |
| removeAdvice: function(thisAdviceObj, thisAdvice, adviceType, once){ |
| // summary: |
| // returns the array index of the first existing connection |
| // betweened the passed advice and this joinpoint. Will be -1 if |
| // none exists. |
| // thisAdviceObj: |
| // the scope in which to locate/execute the named adviceFunc. |
| // thisAdviceFunc: |
| // the name of the function being conected |
| // adviceType: |
| // Optional. String. One of "before", "after", "around", |
| // "before-around", or "after-around". FIXME |
| // once: |
| // Optional. Should this only remove the first occurance of the |
| // connection? |
| var arr = this.getArr(adviceType); |
| var ind = this.hasAdvice(thisAdviceObj, thisAdvice, adviceType, arr); |
| if(ind == -1){ |
| return false; |
| } |
| while(ind != -1){ |
| arr.splice(ind, 1); |
| if(once){ break; } |
| ind = this.hasAdvice(thisAdviceObj, thisAdvice, adviceType, arr); |
| } |
| return true; |
| } |
| }); |
| |
| |
| dojo.provide("dojo.event.topic"); |
| |
| dojo.event.topic = new function(){ |
| this.topics = {}; |
| |
| this.getTopic = function(/*String*/topic){ |
| // summary: |
| // returns a topic implementation object of type |
| // dojo.event.topic.TopicImpl |
| // topic: |
| // a unique, opaque string that names the topic |
| if(!this.topics[topic]){ |
| this.topics[topic] = new this.TopicImpl(topic); |
| } |
| return this.topics[topic]; // a dojo.event.topic.TopicImpl object |
| } |
| |
| this.registerPublisher = function(/*String*/topic, /*Object*/obj, /*String*/funcName){ |
| // summary: |
| // registers a function as a publisher on a topic. Subsequent |
| // calls to the function will cause a publish event on the topic |
| // with the arguments passed to the function passed to registered |
| // listeners. |
| // topic: |
| // a unique, opaque string that names the topic |
| // obj: |
| // the scope to locate the function in |
| // funcName: |
| // the name of the function to register |
| var topic = this.getTopic(topic); |
| topic.registerPublisher(obj, funcName); |
| } |
| |
| this.subscribe = function(/*String*/topic, /*Object*/obj, /*String*/funcName){ |
| // summary: |
| // susbscribes the function to the topic. Subsequent events |
| // dispached to the topic will create a function call for the |
| // obj.funcName() function. |
| // topic: |
| // a unique, opaque string that names the topic |
| // obj: |
| // the scope to locate the function in |
| // funcName: |
| // the name of the function to being registered as a listener |
| var topic = this.getTopic(topic); |
| topic.subscribe(obj, funcName); |
| } |
| |
| this.unsubscribe = function(/*String*/topic, /*Object*/obj, /*String*/funcName){ |
| // summary: |
| // unsubscribes the obj.funcName() from the topic |
| // topic: |
| // a unique, opaque string that names the topic |
| // obj: |
| // the scope to locate the function in |
| // funcName: |
| // the name of the function to being unregistered as a listener |
| var topic = this.getTopic(topic); |
| topic.unsubscribe(obj, funcName); |
| } |
| |
| this.destroy = function(/*String*/topic){ |
| // summary: |
| // destroys the topic and unregisters all listeners |
| // topic: |
| // a unique, opaque string that names the topic |
| this.getTopic(topic).destroy(); |
| delete this.topics[topic]; |
| } |
| |
| this.publishApply = function(/*String*/topic, /*Array*/args){ |
| // summary: |
| // dispatches an event to the topic using the args array as the |
| // source for the call arguments to each listener. This is similar |
| // to JavaScript's built-in Function.apply() |
| // topic: |
| // a unique, opaque string that names the topic |
| // args: |
| // the arguments to be passed into listeners of the topic |
| var topic = this.getTopic(topic); |
| topic.sendMessage.apply(topic, args); |
| } |
| |
| this.publish = function(/*String*/topic, /*Object*/message){ |
| // summary: |
| // manually "publish" to the passed topic |
| // topic: |
| // a unique, opaque string that names the topic |
| // message: |
| // can be an array of parameters (similar to publishApply), or |
| // will be treated as one of many arguments to be passed along in |
| // a "flat" unrolling |
| var topic = this.getTopic(topic); |
| // if message is an array, we treat it as a set of arguments, |
| // otherwise, we just pass on the arguments passed in as-is |
| var args = []; |
| // could we use concat instead here? |
| for(var x=1; x<arguments.length; x++){ |
| args.push(arguments[x]); |
| } |
| topic.sendMessage.apply(topic, args); |
| } |
| } |
| |
| dojo.event.topic.TopicImpl = function(topicName){ |
| // summary: a class to represent topics |
| |
| this.topicName = topicName; |
| |
| this.subscribe = function(/*Object*/listenerObject, /*Function or String*/listenerMethod){ |
| // summary: |
| // use dojo.event.connect() to attach the passed listener to the |
| // topic represented by this object |
| // listenerObject: |
| // if a string and listenerMethod is ommitted, this is treated as |
| // the name of a function in the global namespace. If |
| // listenerMethod is provided, this is the scope to find/execute |
| // the function in. |
| // listenerMethod: |
| // Optional. The function to register. |
| var tf = listenerMethod||listenerObject; |
| var to = (!listenerMethod) ? dj_global : listenerObject; |
| return dojo.event.kwConnect({ // dojo.event.MethodJoinPoint |
| srcObj: this, |
| srcFunc: "sendMessage", |
| adviceObj: to, |
| adviceFunc: tf |
| }); |
| } |
| |
| this.unsubscribe = function(/*Object*/listenerObject, /*Function or String*/listenerMethod){ |
| // summary: |
| // use dojo.event.disconnect() to attach the passed listener to the |
| // topic represented by this object |
| // listenerObject: |
| // if a string and listenerMethod is ommitted, this is treated as |
| // the name of a function in the global namespace. If |
| // listenerMethod is provided, this is the scope to find the |
| // function in. |
| // listenerMethod: |
| // Optional. The function to unregister. |
| var tf = (!listenerMethod) ? listenerObject : listenerMethod; |
| var to = (!listenerMethod) ? null : listenerObject; |
| return dojo.event.kwDisconnect({ // dojo.event.MethodJoinPoint |
| srcObj: this, |
| srcFunc: "sendMessage", |
| adviceObj: to, |
| adviceFunc: tf |
| }); |
| } |
| |
| this._getJoinPoint = function(){ |
| return dojo.event.MethodJoinPoint.getForMethod(this, "sendMessage"); |
| } |
| |
| this.setSquelch = function(/*Boolean*/shouldSquelch){ |
| // summary: |
| // determine whether or not exceptions in the calling of a |
| // listener in the chain should stop execution of the chain. |
| this._getJoinPoint().squelch = shouldSquelch; |
| } |
| |
| this.destroy = function(){ |
| // summary: disconnects all listeners from this topic |
| this._getJoinPoint().disconnect(); |
| } |
| |
| this.registerPublisher = function( /*Object*/publisherObject, |
| /*Function or String*/publisherMethod){ |
| // summary: |
| // registers the passed function as a publisher on this topic. |
| // Each time the function is called, an event will be published on |
| // this topic. |
| // publisherObject: |
| // if a string and listenerMethod is ommitted, this is treated as |
| // the name of a function in the global namespace. If |
| // listenerMethod is provided, this is the scope to find the |
| // function in. |
| // publisherMethod: |
| // Optional. The function to register. |
| dojo.event.connect(publisherObject, publisherMethod, this, "sendMessage"); |
| } |
| |
| this.sendMessage = function(message){ |
| // summary: a stub to be called when a message is sent to the topic. |
| |
| // The message has been propagated |
| } |
| } |
| |
| |
| dojo.provide("dojo.event.browser"); |
| |
| |
| // FIXME: any particular reason this is in the global scope? |
| dojo._ie_clobber = new function(){ |
| this.clobberNodes = []; |
| |
| function nukeProp(node, prop){ |
| // try{ node.removeAttribute(prop); }catch(e){ /* squelch */ } |
| try{ node[prop] = null; }catch(e){ /* squelch */ } |
| try{ delete node[prop]; }catch(e){ /* squelch */ } |
| // FIXME: JotLive needs this, but I'm not sure if it's too slow or not |
| try{ node.removeAttribute(prop); }catch(e){ /* squelch */ } |
| } |
| |
| this.clobber = function(nodeRef){ |
| var na; |
| var tna; |
| if(nodeRef){ |
| tna = nodeRef.all || nodeRef.getElementsByTagName("*"); |
| na = [nodeRef]; |
| for(var x=0; x<tna.length; x++){ |
| // if we're gonna be clobbering the thing, at least make sure |
| // we aren't trying to do it twice |
| if(tna[x]["__doClobber__"]){ |
| na.push(tna[x]); |
| } |
| } |
| }else{ |
| try{ window.onload = null; }catch(e){} |
| na = (this.clobberNodes.length) ? this.clobberNodes : document.all; |
| } |
| tna = null; |
| var basis = {}; |
| for(var i = na.length-1; i>=0; i=i-1){ |
| var el = na[i]; |
| try{ |
| if(el && el["__clobberAttrs__"]){ |
| for(var j=0; j<el.__clobberAttrs__.length; j++){ |
| nukeProp(el, el.__clobberAttrs__[j]); |
| } |
| nukeProp(el, "__clobberAttrs__"); |
| nukeProp(el, "__doClobber__"); |
| } |
| }catch(e){ /* squelch! */}; |
| } |
| na = null; |
| } |
| } |
| |
| if(dojo.render.html.ie){ |
| dojo.addOnUnload(function(){ |
| dojo._ie_clobber.clobber(); |
| try{ |
| if((dojo["widget"])&&(dojo.widget["manager"])){ |
| dojo.widget.manager.destroyAll(); |
| } |
| }catch(e){} |
| |
| // Workaround for IE leak recommended in ticket #1727 by schallm |
| if(dojo.widget){ |
| for(var name in dojo.widget._templateCache){ |
| if(dojo.widget._templateCache[name].node){ |
| dojo.dom.destroyNode(dojo.widget._templateCache[name].node); |
| dojo.widget._templateCache[name].node = null; |
| delete dojo.widget._templateCache[name].node; |
| } |
| } |
| } |
| |
| try{ window.onload = null; }catch(e){} |
| try{ window.onunload = null; }catch(e){} |
| dojo._ie_clobber.clobberNodes = []; |
| // CollectGarbage(); |
| }); |
| } |
| |
| dojo.event.browser = new function(){ |
| |
| var clobberIdx = 0; |
| |
| this.normalizedEventName = function(/*String*/eventName){ |
| switch(eventName){ |
| case "CheckboxStateChange": |
| case "DOMAttrModified": |
| case "DOMMenuItemActive": |
| case "DOMMenuItemInactive": |
| case "DOMMouseScroll": |
| case "DOMNodeInserted": |
| case "DOMNodeRemoved": |
| case "RadioStateChange": |
| return eventName; |
| break; |
| default: |
| var lcn = eventName.toLowerCase(); |
| return (lcn.indexOf("on") == 0) ? lcn.substr(2) : lcn; |
| break; |
| } |
| } |
| |
| this.clean = function(/*DOMNode*/node){ |
| // summary: |
| // removes native event handlers so that destruction of the node |
| // will not leak memory. On most browsers this is a no-op, but |
| // it's critical for manual node removal on IE. |
| // node: |
| // A DOM node. All of it's children will also be cleaned. |
| if(dojo.render.html.ie){ |
| dojo._ie_clobber.clobber(node); |
| } |
| } |
| |
| this.addClobberNode = function(/*DOMNode*/node){ |
| // summary: |
| // register the passed node to support event stripping |
| // node: |
| // A DOM node |
| if(!dojo.render.html.ie){ return; } |
| if(!node["__doClobber__"]){ |
| node.__doClobber__ = true; |
| dojo._ie_clobber.clobberNodes.push(node); |
| // this might not be the most efficient thing to do, but it's |
| // much less error prone than other approaches which were |
| // previously tried and failed |
| node.__clobberAttrs__ = []; |
| } |
| } |
| |
| this.addClobberNodeAttrs = function(/*DOMNode*/node, /*Array*/props){ |
| // summary: |
| // register the passed node to support event stripping |
| // node: |
| // A DOM node to stip properties from later |
| // props: |
| // A list of propeties to strip from the node |
| if(!dojo.render.html.ie){ return; } |
| this.addClobberNode(node); |
| for(var x=0; x<props.length; x++){ |
| node.__clobberAttrs__.push(props[x]); |
| } |
| } |
| |
| this.removeListener = function( /*DOMNode*/ node, |
| /*String*/ evtName, |
| /*Function*/fp, |
| /*Boolean*/ capture){ |
| // summary: |
| // clobbers the listener from the node |
| // evtName: |
| // the name of the handler to remove the function from |
| // node: |
| // DOM node to attach the event to |
| // fp: |
| // the function to register |
| // capture: |
| // Optional. should this listener prevent propigation? |
| if(!capture){ var capture = false; } |
| evtName = dojo.event.browser.normalizedEventName(evtName); |
| if(evtName == "key"){ |
| if(dojo.render.html.ie){ |
| this.removeListener(node, "onkeydown", fp, capture); |
| } |
| evtName = "keypress"; |
| } |
| // FIXME: this is mostly a punt, we aren't actually doing anything on IE |
| if(node.removeEventListener){ |
| node.removeEventListener(evtName, fp, capture); |
| } |
| } |
| |
| this.addListener = function(/*DOMNode*/node, /*String*/evtName, /*Function*/fp, /*Boolean*/capture, /*Boolean*/dontFix){ |
| // summary: |
| // adds a listener to the node |
| // evtName: |
| // the name of the handler to add the listener to can be either of |
| // the form "onclick" or "click" |
| // node: |
| // DOM node to attach the event to |
| // fp: |
| // the function to register |
| // capture: |
| // Optional. Should this listener prevent propigation? |
| // dontFix: |
| // Optional. Should we avoid registering a new closure around the |
| // listener to enable fixEvent for dispatch of the registered |
| // function? |
| if(!node){ return; } // FIXME: log and/or bail? |
| if(!capture){ var capture = false; } |
| evtName = dojo.event.browser.normalizedEventName(evtName); |
| if(evtName == "key"){ |
| if(dojo.render.html.ie){ |
| this.addListener(node, "onkeydown", fp, capture, dontFix); |
| } |
| evtName = "keypress"; |
| } |
| |
| if(!dontFix){ |
| // build yet another closure around fp in order to inject fixEvent |
| // around the resulting event |
| var newfp = function(evt){ |
| if(!evt){ evt = window.event; } |
| var ret = fp(dojo.event.browser.fixEvent(evt, this)); |
| if(capture){ |
| dojo.event.browser.stopEvent(evt); |
| } |
| return ret; |
| } |
| }else{ |
| newfp = fp; |
| } |
| |
| if(node.addEventListener){ |
| node.addEventListener(evtName, newfp, capture); |
| return newfp; |
| }else{ |
| evtName = "on"+evtName; |
| if(typeof node[evtName] == "function" ){ |
| var oldEvt = node[evtName]; |
| node[evtName] = function(e){ |
| oldEvt(e); |
| return newfp(e); |
| } |
| }else{ |
| node[evtName]=newfp; |
| } |
| if(dojo.render.html.ie){ |
| this.addClobberNodeAttrs(node, [evtName]); |
| } |
| return newfp; |
| } |
| } |
| |
| this.isEvent = function(/*Object*/obj){ |
| // summary: |
| // Tries to determine whether or not the object is a DOM event. |
| |
| // FIXME: event detection hack ... could test for additional attributes |
| // if necessary |
| return (typeof obj != "undefined")&&(obj)&&(typeof Event != "undefined")&&(obj.eventPhase); // Boolean |
| // Event does not support instanceof in Opera, otherwise: |
| //return (typeof Event != "undefined")&&(obj instanceof Event); |
| } |
| |
| this.currentEvent = null; |
| |
| this.callListener = function(/*Function*/listener, /*DOMNode*/curTarget){ |
| // summary: |
| // calls the specified listener in the context of the passed node |
| // with the current DOM event object as the only parameter |
| // listener: |
| // the function to call |
| // curTarget: |
| // the Node to call the function in the scope of |
| if(typeof listener != 'function'){ |
| dojo.raise("listener not a function: " + listener); |
| } |
| dojo.event.browser.currentEvent.currentTarget = curTarget; |
| return listener.call(curTarget, dojo.event.browser.currentEvent); |
| } |
| |
| this._stopPropagation = function(){ |
| dojo.event.browser.currentEvent.cancelBubble = true; |
| } |
| |
| this._preventDefault = function(){ |
| dojo.event.browser.currentEvent.returnValue = false; |
| } |
| |
| this.keys = { |
| KEY_BACKSPACE: 8, |
| KEY_TAB: 9, |
| KEY_CLEAR: 12, |
| KEY_ENTER: 13, |
| KEY_SHIFT: 16, |
| KEY_CTRL: 17, |
| KEY_ALT: 18, |
| KEY_PAUSE: 19, |
| KEY_CAPS_LOCK: 20, |
| KEY_ESCAPE: 27, |
| KEY_SPACE: 32, |
| KEY_PAGE_UP: 33, |
| KEY_PAGE_DOWN: 34, |
| KEY_END: 35, |
| KEY_HOME: 36, |
| KEY_LEFT_ARROW: 37, |
| KEY_UP_ARROW: 38, |
| KEY_RIGHT_ARROW: 39, |
| KEY_DOWN_ARROW: 40, |
| KEY_INSERT: 45, |
| KEY_DELETE: 46, |
| KEY_HELP: 47, |
| KEY_LEFT_WINDOW: 91, |
| KEY_RIGHT_WINDOW: 92, |
| KEY_SELECT: 93, |
| KEY_NUMPAD_0: 96, |
| KEY_NUMPAD_1: 97, |
| KEY_NUMPAD_2: 98, |
| KEY_NUMPAD_3: 99, |
| KEY_NUMPAD_4: 100, |
| KEY_NUMPAD_5: 101, |
| KEY_NUMPAD_6: 102, |
| KEY_NUMPAD_7: 103, |
| KEY_NUMPAD_8: 104, |
| KEY_NUMPAD_9: 105, |
| KEY_NUMPAD_MULTIPLY: 106, |
| KEY_NUMPAD_PLUS: 107, |
| KEY_NUMPAD_ENTER: 108, |
| KEY_NUMPAD_MINUS: 109, |
| KEY_NUMPAD_PERIOD: 110, |
| KEY_NUMPAD_DIVIDE: 111, |
| KEY_F1: 112, |
| KEY_F2: 113, |
| KEY_F3: 114, |
| KEY_F4: 115, |
| KEY_F5: 116, |
| KEY_F6: 117, |
| KEY_F7: 118, |
| KEY_F8: 119, |
| KEY_F9: 120, |
| KEY_F10: 121, |
| KEY_F11: 122, |
| KEY_F12: 123, |
| KEY_F13: 124, |
| KEY_F14: 125, |
| KEY_F15: 126, |
| KEY_NUM_LOCK: 144, |
| KEY_SCROLL_LOCK: 145 |
| }; |
| |
| // reverse lookup |
| this.revKeys = []; |
| for(var key in this.keys){ |
| this.revKeys[this.keys[key]] = key; |
| } |
| |
| this.fixEvent = function(/*Event*/evt, /*DOMNode*/sender){ |
| // summary: |
| // normalizes properties on the event object including event |
| // bubbling methods, keystroke normalization, and x/y positions |
| // evt: the native event object |
| // sender: the node to treat as "currentTarget" |
| if(!evt){ |
| if(window["event"]){ |
| evt = window.event; |
| } |
| } |
| |
| if((evt["type"])&&(evt["type"].indexOf("key") == 0)){ // key events |
| evt.keys = this.revKeys; |
| // FIXME: how can we eliminate this iteration? |
| for(var key in this.keys){ |
| evt[key] = this.keys[key]; |
| } |
| if(evt["type"] == "keydown" && dojo.render.html.ie){ |
| switch(evt.keyCode){ |
| case evt.KEY_SHIFT: |
| case evt.KEY_CTRL: |
| case evt.KEY_ALT: |
| case evt.KEY_CAPS_LOCK: |
| case evt.KEY_LEFT_WINDOW: |
| case evt.KEY_RIGHT_WINDOW: |
| case evt.KEY_SELECT: |
| case evt.KEY_NUM_LOCK: |
| case evt.KEY_SCROLL_LOCK: |
| // I'll get these in keypress after the OS munges them based on numlock |
| case evt.KEY_NUMPAD_0: |
| case evt.KEY_NUMPAD_1: |
| case evt.KEY_NUMPAD_2: |
| case evt.KEY_NUMPAD_3: |
| case evt.KEY_NUMPAD_4: |
| case evt.KEY_NUMPAD_5: |
| case evt.KEY_NUMPAD_6: |
| case evt.KEY_NUMPAD_7: |
| case evt.KEY_NUMPAD_8: |
| case evt.KEY_NUMPAD_9: |
| case evt.KEY_NUMPAD_PERIOD: |
| break; // just ignore the keys that can morph |
| case evt.KEY_NUMPAD_MULTIPLY: |
| case evt.KEY_NUMPAD_PLUS: |
| case evt.KEY_NUMPAD_ENTER: |
| case evt.KEY_NUMPAD_MINUS: |
| case evt.KEY_NUMPAD_DIVIDE: |
| break; // I could handle these but just pick them up in keypress |
| case evt.KEY_PAUSE: |
| case evt.KEY_TAB: |
| case evt.KEY_BACKSPACE: |
| case evt.KEY_ENTER: |
| case evt.KEY_ESCAPE: |
| case evt.KEY_PAGE_UP: |
| case evt.KEY_PAGE_DOWN: |
| case evt.KEY_END: |
| case evt.KEY_HOME: |
| case evt.KEY_LEFT_ARROW: |
| case evt.KEY_UP_ARROW: |
| case evt.KEY_RIGHT_ARROW: |
| case evt.KEY_DOWN_ARROW: |
| case evt.KEY_INSERT: |
| case evt.KEY_DELETE: |
| case evt.KEY_F1: |
| case evt.KEY_F2: |
| case evt.KEY_F3: |
| case evt.KEY_F4: |
| case evt.KEY_F5: |
| case evt.KEY_F6: |
| case evt.KEY_F7: |
| case evt.KEY_F8: |
| case evt.KEY_F9: |
| case evt.KEY_F10: |
| case evt.KEY_F11: |
| case evt.KEY_F12: |
| case evt.KEY_F12: |
| case evt.KEY_F13: |
| case evt.KEY_F14: |
| case evt.KEY_F15: |
| case evt.KEY_CLEAR: |
| case evt.KEY_HELP: |
| evt.key = evt.keyCode; |
| break; |
| default: |
| if(evt.ctrlKey || evt.altKey){ |
| var unifiedCharCode = evt.keyCode; |
| // if lower case but keycode is uppercase, convert it |
| if(unifiedCharCode >= 65 && unifiedCharCode <= 90 && evt.shiftKey == false){ |
| unifiedCharCode += 32; |
| } |
| if(unifiedCharCode >= 1 && unifiedCharCode <= 26 && evt.ctrlKey){ |
| unifiedCharCode += 96; // 001-032 = ctrl+[a-z] |
| } |
| evt.key = String.fromCharCode(unifiedCharCode); |
| } |
| } |
| } else if(evt["type"] == "keypress"){ |
| if(dojo.render.html.opera){ |
| if(evt.which == 0){ |
| evt.key = evt.keyCode; |
| }else if(evt.which > 0){ |
| switch(evt.which){ |
| case evt.KEY_SHIFT: |
| case evt.KEY_CTRL: |
| case evt.KEY_ALT: |
| case evt.KEY_CAPS_LOCK: |
| case evt.KEY_NUM_LOCK: |
| case evt.KEY_SCROLL_LOCK: |
| break; |
| case evt.KEY_PAUSE: |
| case evt.KEY_TAB: |
| case evt.KEY_BACKSPACE: |
| case evt.KEY_ENTER: |
| case evt.KEY_ESCAPE: |
| evt.key = evt.which; |
| break; |
| default: |
| var unifiedCharCode = evt.which; |
| if((evt.ctrlKey || evt.altKey || evt.metaKey) && (evt.which >= 65 && evt.which <= 90 && evt.shiftKey == false)){ |
| unifiedCharCode += 32; |
| } |
| evt.key = String.fromCharCode(unifiedCharCode); |
| } |
| } |
| }else if(dojo.render.html.ie){ // catch some IE keys that are hard to get in keyDown |
| // key combinations were handled in onKeyDown |
| if(!evt.ctrlKey && !evt.altKey && evt.keyCode >= evt.KEY_SPACE){ |
| evt.key = String.fromCharCode(evt.keyCode); |
| } |
| }else if(dojo.render.html.safari){ |
| switch(evt.keyCode){ |
| case 25: evt.key = evt.KEY_TAB; evt.shift = true;break; |
| case 63232: evt.key = evt.KEY_UP_ARROW; break; |
| case 63233: evt.key = evt.KEY_DOWN_ARROW; break; |
| case 63234: evt.key = evt.KEY_LEFT_ARROW; break; |
| case 63235: evt.key = evt.KEY_RIGHT_ARROW; break; |
| case 63236: evt.key = evt.KEY_F1; break; |
| case 63237: evt.key = evt.KEY_F2; break; |
| case 63238: evt.key = evt.KEY_F3; break; |
| case 63239: evt.key = evt.KEY_F4; break; |
| case 63240: evt.key = evt.KEY_F5; break; |
| case 63241: evt.key = evt.KEY_F6; break; |
| case 63242: evt.key = evt.KEY_F7; break; |
| case 63243: evt.key = evt.KEY_F8; break; |
| case 63244: evt.key = evt.KEY_F9; break; |
| case 63245: evt.key = evt.KEY_F10; break; |
| case 63246: evt.key = evt.KEY_F11; break; |
| case 63247: evt.key = evt.KEY_F12; break; |
| case 63250: evt.key = evt.KEY_PAUSE; break; |
| case 63272: evt.key = evt.KEY_DELETE; break; |
| case 63273: evt.key = evt.KEY_HOME; break; |
| case 63275: evt.key = evt.KEY_END; break; |
| case 63276: evt.key = evt.KEY_PAGE_UP; break; |
| case 63277: evt.key = evt.KEY_PAGE_DOWN; break; |
| case 63302: evt.key = evt.KEY_INSERT; break; |
| case 63248://prtscr |
| case 63249://scrolllock |
| case 63289://numlock |
| break; |
| default: |
| evt.key = evt.charCode >= evt.KEY_SPACE ? String.fromCharCode(evt.charCode) : evt.keyCode; |
| } |
| }else{ |
| evt.key = evt.charCode > 0 ? String.fromCharCode(evt.charCode) : evt.keyCode; |
| } |
| } |
| } |
| if(dojo.render.html.ie){ |
| if(!evt.target){ evt.target = evt.srcElement; } |
| if(!evt.currentTarget){ evt.currentTarget = (sender ? sender : evt.srcElement); } |
| if(!evt.layerX){ evt.layerX = evt.offsetX; } |
| if(!evt.layerY){ evt.layerY = evt.offsetY; } |
| // FIXME: scroll position query is duped from dojo.html to avoid dependency on that entire module |
| // DONOT replace the following to use dojo.body(), in IE, document.documentElement should be used |
| // here rather than document.body |
| var doc = (evt.srcElement && evt.srcElement.ownerDocument) ? evt.srcElement.ownerDocument : document; |
| var docBody = ((dojo.render.html.ie55)||(doc["compatMode"] == "BackCompat")) ? doc.body : doc.documentElement; |
| if(!evt.pageX){ evt.pageX = evt.clientX + (docBody.scrollLeft || 0) } |
| if(!evt.pageY){ evt.pageY = evt.clientY + (docBody.scrollTop || 0) } |
| // mouseover |
| if(evt.type == "mouseover"){ evt.relatedTarget = evt.fromElement; } |
| // mouseout |
| if(evt.type == "mouseout"){ evt.relatedTarget = evt.toElement; } |
| this.currentEvent = evt; |
| evt.callListener = this.callListener; |
| evt.stopPropagation = this._stopPropagation; |
| evt.preventDefault = this._preventDefault; |
| } |
| return evt; // Event |
| } |
| |
| this.stopEvent = function(/*Event*/evt){ |
| // summary: |
| // prevents propigation and clobbers the default action of the |
| // passed event |
| // evt: Optional for IE. The native event object. |
| if(window.event){ |
| evt.cancelBubble = true; |
| evt.returnValue = false; |
| }else{ |
| evt.preventDefault(); |
| evt.stopPropagation(); |
| } |
| } |
| } |
| |
| dojo.kwCompoundRequire({ |
| common: ["dojo.event.common", "dojo.event.topic"], |
| browser: ["dojo.event.browser"], |
| dashboard: ["dojo.event.browser"] |
| }); |
| dojo.provide("dojo.event.*"); |
| |
| dojo.provide("dojo.gfx.color"); |
| |
| |
| |
| // TODO: rewrite the "x2y" methods to take advantage of the parsing |
| // abilities of the Color object. Also, beef up the Color |
| // object (as possible) to parse most common formats |
| |
| // takes an r, g, b, a(lpha) value, [r, g, b, a] array, "rgb(...)" string, hex string (#aaa, #aaaaaa, aaaaaaa) |
| dojo.gfx.color.Color = function(r, g, b, a) { |
| // dojo.debug("r:", r[0], "g:", r[1], "b:", r[2]); |
| if(dojo.lang.isArray(r)){ |
| this.r = r[0]; |
| this.g = r[1]; |
| this.b = r[2]; |
| this.a = r[3]||1.0; |
| }else if(dojo.lang.isString(r)){ |
| var rgb = dojo.gfx.color.extractRGB(r); |
| this.r = rgb[0]; |
| this.g = rgb[1]; |
| this.b = rgb[2]; |
| this.a = g||1.0; |
| }else if(r instanceof dojo.gfx.color.Color){ |
| // why does this create a new instance if we were passed one? |
| this.r = r.r; |
| this.b = r.b; |
| this.g = r.g; |
| this.a = r.a; |
| }else{ |
| this.r = r; |
| this.g = g; |
| this.b = b; |
| this.a = a; |
| } |
| } |
| |
| dojo.gfx.color.Color.fromArray = function(arr) { |
| return new dojo.gfx.color.Color(arr[0], arr[1], arr[2], arr[3]); |
| } |
| |
| dojo.extend(dojo.gfx.color.Color, { |
| toRgb: function(includeAlpha) { |
| if(includeAlpha) { |
| return this.toRgba(); |
| } else { |
| return [this.r, this.g, this.b]; |
| } |
| }, |
| toRgba: function() { |
| return [this.r, this.g, this.b, this.a]; |
| }, |
| toHex: function() { |
| return dojo.gfx.color.rgb2hex(this.toRgb()); |
| }, |
| toCss: function() { |
| return "rgb(" + this.toRgb().join() + ")"; |
| }, |
| toString: function() { |
| return this.toHex(); // decent default? |
| }, |
| blend: function(color, weight){ |
| var rgb = null; |
| if(dojo.lang.isArray(color)){ |
| rgb = color; |
| }else if(color instanceof dojo.gfx.color.Color){ |
| rgb = color.toRgb(); |
| }else{ |
| rgb = new dojo.gfx.color.Color(color).toRgb(); |
| } |
| return dojo.gfx.color.blend(this.toRgb(), rgb, weight); |
| } |
| }); |
| |
| dojo.gfx.color.named = { |
| white: [255,255,255], |
| black: [0,0,0], |
| red: [255,0,0], |
| green: [0,255,0], |
| lime: [0,255,0], |
| blue: [0,0,255], |
| navy: [0,0,128], |
| gray: [128,128,128], |
| silver: [192,192,192] |
| }; |
| |
| dojo.gfx.color.blend = function(a, b, weight){ |
| // summary: |
| // blend colors a and b (both as RGB array or hex strings) with weight |
| // from -1 to +1, 0 being a 50/50 blend |
| if(typeof a == "string"){ |
| return dojo.gfx.color.blendHex(a, b, weight); |
| } |
| if(!weight){ |
| weight = 0; |
| } |
| weight = Math.min(Math.max(-1, weight), 1); |
| |
| // alex: this interface blows. |
| // map -1 to 1 to the range 0 to 1 |
| weight = ((weight + 1)/2); |
| |
| var c = []; |
| |
| // var stop = (1000*weight); |
| for(var x = 0; x < 3; x++){ |
| c[x] = parseInt( b[x] + ( (a[x] - b[x]) * weight) ); |
| } |
| return c; |
| } |
| |
| // very convenient blend that takes and returns hex values |
| // (will get called automatically by blend when blend gets strings) |
| dojo.gfx.color.blendHex = function(a, b, weight) { |
| return dojo.gfx.color.rgb2hex(dojo.gfx.color.blend(dojo.gfx.color.hex2rgb(a), dojo.gfx.color.hex2rgb(b), weight)); |
| } |
| |
| // get RGB array from css-style color declarations |
| dojo.gfx.color.extractRGB = function(color) { |
| var hex = "0123456789abcdef"; |
| color = color.toLowerCase(); |
| if( color.indexOf("rgb") == 0 ) { |
| var matches = color.match(/rgba*\((\d+), *(\d+), *(\d+)/i); |
| var ret = matches.splice(1, 3); |
| return ret; |
| } else { |
| var colors = dojo.gfx.color.hex2rgb(color); |
| if(colors) { |
| return colors; |
| } else { |
| // named color (how many do we support?) |
| return dojo.gfx.color.named[color] || [255, 255, 255]; |
| } |
| } |
| } |
| |
| dojo.gfx.color.hex2rgb = function(hex) { |
| var hexNum = "0123456789ABCDEF"; |
| var rgb = new Array(3); |
| if( hex.indexOf("#") == 0 ) { hex = hex.substring(1); } |
| hex = hex.toUpperCase(); |
| if(hex.replace(new RegExp("["+hexNum+"]", "g"), "") != "") { |
| return null; |
| } |
| if( hex.length == 3 ) { |
| rgb[0] = hex.charAt(0) + hex.charAt(0) |
| rgb[1] = hex.charAt(1) + hex.charAt(1) |
| rgb[2] = hex.charAt(2) + hex.charAt(2); |
| } else { |
| rgb[0] = hex.substring(0, 2); |
| rgb[1] = hex.substring(2, 4); |
| rgb[2] = hex.substring(4); |
| } |
| for(var i = 0; i < rgb.length; i++) { |
| rgb[i] = hexNum.indexOf(rgb[i].charAt(0)) * 16 + hexNum.indexOf(rgb[i].charAt(1)); |
| } |
| return rgb; |
| } |
| |
| dojo.gfx.color.rgb2hex = function(r, g, b) { |
| if(dojo.lang.isArray(r)) { |
| g = r[1] || 0; |
| b = r[2] || 0; |
| r = r[0] || 0; |
| } |
| var ret = dojo.lang.map([r, g, b], function(x) { |
| x = new Number(x); |
| var s = x.toString(16); |
| while(s.length < 2) { s = "0" + s; } |
| return s; |
| }); |
| ret.unshift("#"); |
| return ret.join(""); |
| } |
| |
| dojo.provide("dojo.lfx.Animation"); |
| |
| |
| |
| /* |
| Animation package based on Dan Pupius' work: http://pupius.co.uk/js/Toolkit.Drawing.js |
| */ |
| dojo.lfx.Line = function(/*int*/ start, /*int*/ end){ |
| // summary: dojo.lfx.Line is the object used to generate values |
| // from a start value to an end value |
| this.start = start; |
| this.end = end; |
| if(dojo.lang.isArray(start)){ |
| /* start: Array |
| end: Array |
| pId: a */ |
| var diff = []; |
| dojo.lang.forEach(this.start, function(s,i){ |
| diff[i] = this.end[i] - s; |
| }, this); |
| |
| this.getValue = function(/*float*/ n){ |
| var res = []; |
| dojo.lang.forEach(this.start, function(s, i){ |
| res[i] = (diff[i] * n) + s; |
| }, this); |
| return res; // Array |
| } |
| }else{ |
| var diff = end - start; |
| |
| this.getValue = function(/*float*/ n){ |
| // summary: returns the point on the line |
| // n: a floating point number greater than 0 and less than 1 |
| return (diff * n) + this.start; // Decimal |
| } |
| } |
| } |
| |
| if((dojo.render.html.khtml)&&(!dojo.render.html.safari)){ |
| // the cool kids are obviously not using konqueror... |
| // found a very wierd bug in floats constants, 1.5 evals as 1 |
| // seems somebody mixed up ints and floats in 3.5.4 ?? |
| // FIXME: investigate more and post a KDE bug (Fredrik) |
| dojo.lfx.easeDefault = function(/*Decimal?*/ n){ |
| // summary: Returns the point for point n on a sin wave. |
| return (parseFloat("0.5")+((Math.sin( (n+parseFloat("1.5")) * Math.PI))/2)); |
| } |
| }else{ |
| dojo.lfx.easeDefault = function(/*Decimal?*/ n){ |
| return (0.5+((Math.sin( (n+1.5) * Math.PI))/2)); |
| } |
| } |
| |
| dojo.lfx.easeIn = function(/*Decimal?*/ n){ |
| // summary: returns the point on an easing curve |
| // n: a floating point number greater than 0 and less than 1 |
| return Math.pow(n, 3); |
| } |
| |
| dojo.lfx.easeOut = function(/*Decimal?*/ n){ |
| // summary: returns the point on the line |
| // n: a floating point number greater than 0 and less than 1 |
| return ( 1 - Math.pow(1 - n, 3) ); |
| } |
| |
| dojo.lfx.easeInOut = function(/*Decimal?*/ n){ |
| // summary: returns the point on the line |
| // n: a floating point number greater than 0 and less than 1 |
| return ( (3 * Math.pow(n, 2)) - (2 * Math.pow(n, 3)) ); |
| } |
| |
| dojo.lfx.IAnimation = function(){ |
| // summary: dojo.lfx.IAnimation is an interface that implements |
| // commonly used functions of animation objects |
| } |
| dojo.lang.extend(dojo.lfx.IAnimation, { |
| // public properties |
| curve: null, |
| duration: 1000, |
| easing: null, |
| repeatCount: 0, |
| rate: 10, |
| |
| // events |
| handler: null, |
| beforeBegin: null, |
| onBegin: null, |
| onAnimate: null, |
| onEnd: null, |
| onPlay: null, |
| onPause: null, |
| onStop: null, |
| |
| // public methods |
| play: null, |
| pause: null, |
| stop: null, |
| |
| connect: function(/*Event*/ evt, /*Object*/ scope, /*Function*/ newFunc){ |
| // summary: Convenience function. Quickly connect to an event |
| // of this object and save the old functions connected to it. |
| // evt: The name of the event to connect to. |
| // scope: the scope in which to run newFunc. |
| // newFunc: the function to run when evt is fired. |
| if(!newFunc){ |
| /* scope: Function |
| newFunc: null |
| pId: f */ |
| newFunc = scope; |
| scope = this; |
| } |
| newFunc = dojo.lang.hitch(scope, newFunc); |
| var oldFunc = this[evt]||function(){}; |
| this[evt] = function(){ |
| var ret = oldFunc.apply(this, arguments); |
| newFunc.apply(this, arguments); |
| return ret; |
| } |
| return this; // dojo.lfx.IAnimation |
| }, |
| |
| fire: function(/*Event*/ evt, /*Array*/ args){ |
| // summary: Convenience function. Fire event "evt" and pass it |
| // the arguments specified in "args". |
| // evt: The event to fire. |
| // args: The arguments to pass to the event. |
| if(this[evt]){ |
| this[evt].apply(this, (args||[])); |
| } |
| return this; // dojo.lfx.IAnimation |
| }, |
| |
| repeat: function(/*int*/ count){ |
| // summary: Set the repeat count of this object. |
| // count: How many times to repeat the animation. |
| this.repeatCount = count; |
| return this; // dojo.lfx.IAnimation |
| }, |
| |
| // private properties |
| _active: false, |
| _paused: false |
| }); |
| |
| dojo.lfx.Animation = function( /*Object*/ handlers, |
| /*int*/ duration, |
| /*dojo.lfx.Line*/ curve, |
| /*function*/ easing, |
| /*int*/ repeatCount, |
| /*int*/ rate){ |
| // summary |
| // a generic animation object that fires callbacks into it's handlers |
| // object at various states |
| // handlers: { handler: Function?, onstart: Function?, onstop: Function?, onanimate: Function? } |
| dojo.lfx.IAnimation.call(this); |
| if(dojo.lang.isNumber(handlers)||(!handlers && duration.getValue)){ |
| // no handlers argument: |
| rate = repeatCount; |
| repeatCount = easing; |
| easing = curve; |
| curve = duration; |
| duration = handlers; |
| handlers = null; |
| }else if(handlers.getValue||dojo.lang.isArray(handlers)){ |
| // no handlers or duration: |
| rate = easing; |
| repeatCount = curve; |
| easing = duration; |
| curve = handlers; |
| duration = null; |
| handlers = null; |
| } |
| if(dojo.lang.isArray(curve)){ |
| /* curve: Array |
| pId: a */ |
| this.curve = new dojo.lfx.Line(curve[0], curve[1]); |
| }else{ |
| this.curve = curve; |
| } |
| if(duration != null && duration > 0){ this.duration = duration; } |
| if(repeatCount){ this.repeatCount = repeatCount; } |
| if(rate){ this.rate = rate; } |
| if(handlers){ |
| dojo.lang.forEach([ |
| "handler", "beforeBegin", "onBegin", |
| "onEnd", "onPlay", "onStop", "onAnimate" |
| ], function(item){ |
| if(handlers[item]){ |
| this.connect(item, handlers[item]); |
| } |
| }, this); |
| } |
| if(easing && dojo.lang.isFunction(easing)){ |
| this.easing=easing; |
| } |
| } |
| dojo.inherits(dojo.lfx.Animation, dojo.lfx.IAnimation); |
| dojo.lang.extend(dojo.lfx.Animation, { |
| // "private" properties |
| _startTime: null, |
| _endTime: null, |
| _timer: null, |
| _percent: 0, |
| _startRepeatCount: 0, |
| |
| // public methods |
| play: function(/*int?*/ delay, /*bool?*/ gotoStart){ |
| // summary: Start the animation. |
| // delay: How many milliseconds to delay before starting. |
| // gotoStart: If true, starts the animation from the beginning; otherwise, |
| // starts it from its current position. |
| if(gotoStart){ |
| clearTimeout(this._timer); |
| this._active = false; |
| this._paused = false; |
| this._percent = 0; |
| }else if(this._active && !this._paused){ |
| return this; // dojo.lfx.Animation |
| } |
| |
| this.fire("handler", ["beforeBegin"]); |
| this.fire("beforeBegin"); |
| |
| if(delay > 0){ |
| setTimeout(dojo.lang.hitch(this, function(){ this.play(null, gotoStart); }), delay); |
| return this; // dojo.lfx.Animation |
| } |
| |
| this._startTime = new Date().valueOf(); |
| if(this._paused){ |
| this._startTime -= (this.duration * this._percent / 100); |
| } |
| this._endTime = this._startTime + this.duration; |
| |
| this._active = true; |
| this._paused = false; |
| |
| var step = this._percent / 100; |
| var value = this.curve.getValue(step); |
| if(this._percent == 0 ){ |
| if(!this._startRepeatCount){ |
| this._startRepeatCount = this.repeatCount; |
| } |
| this.fire("handler", ["begin", value]); |
| this.fire("onBegin", [value]); |
| } |
| |
| this.fire("handler", ["play", value]); |
| this.fire("onPlay", [value]); |
| |
| this._cycle(); |
| return this; // dojo.lfx.Animation |
| }, |
| |
| pause: function(){ |
| // summary: Pauses a running animation. |
| clearTimeout(this._timer); |
| if(!this._active){ return this; /*dojo.lfx.Animation*/} |
| this._paused = true; |
| var value = this.curve.getValue(this._percent / 100); |
| this.fire("handler", ["pause", value]); |
| this.fire("onPause", [value]); |
| return this; // dojo.lfx.Animation |
| }, |
| |
| gotoPercent: function(/*Decimal*/ pct, /*bool?*/ andPlay){ |
| // summary: Sets the progress of the animation. |
| // pct: A percentage in decimal notation (between and including 0.0 and 1.0). |
| // andPlay: If true, play the animation after setting the progress. |
| clearTimeout(this._timer); |
| this._active = true; |
| this._paused = true; |
| this._percent = pct; |
| if(andPlay){ this.play(); } |
| return this; // dojo.lfx.Animation |
| }, |
| |
| stop: function(/*bool?*/ gotoEnd){ |
| // summary: Stops a running animation. |
| // gotoEnd: If true, the animation will end. |
| clearTimeout(this._timer); |
| var step = this._percent / 100; |
| if(gotoEnd){ |
| step = 1; |
| } |
| var value = this.curve.getValue(step); |
| this.fire("handler", ["stop", value]); |
| this.fire("onStop", [value]); |
| this._active = false; |
| this._paused = false; |
| return this; // dojo.lfx.Animation |
| }, |
| |
| status: function(){ |
| // summary: Returns a string representation of the status of |
| // the animation. |
| if(this._active){ |
| return this._paused ? "paused" : "playing"; // String |
| }else{ |
| return "stopped"; // String |
| } |
| return this; |
| }, |
| |
| // "private" methods |
| _cycle: function(){ |
| clearTimeout(this._timer); |
| if(this._active){ |
| var curr = new Date().valueOf(); |
| var step = (curr - this._startTime) / (this._endTime - this._startTime); |
| |
| if(step >= 1){ |
| step = 1; |
| this._percent = 100; |
| }else{ |
| this._percent = step * 100; |
| } |
| |
| // Perform easing |
| if((this.easing)&&(dojo.lang.isFunction(this.easing))){ |
| step = this.easing(step); |
| } |
| |
| var value = this.curve.getValue(step); |
| this.fire("handler", ["animate", value]); |
| this.fire("onAnimate", [value]); |
| |
| if( step < 1 ){ |
| this._timer = setTimeout(dojo.lang.hitch(this, "_cycle"), this.rate); |
| }else{ |
| this._active = false; |
| this.fire("handler", ["end"]); |
| this.fire("onEnd"); |
| |
| if(this.repeatCount > 0){ |
| this.repeatCount--; |
| this.play(null, true); |
| }else if(this.repeatCount == -1){ |
| this.play(null, true); |
| }else{ |
| if(this._startRepeatCount){ |
| this.repeatCount = this._startRepeatCount; |
| this._startRepeatCount = 0; |
| } |
| } |
| } |
| } |
| return this; // dojo.lfx.Animation |
| } |
| }); |
| |
| dojo.lfx.Combine = function(/*dojo.lfx.IAnimation...*/ animations){ |
| // summary: An animation object to play animations passed to it at the same time. |
| dojo.lfx.IAnimation.call(this); |
| this._anims = []; |
| this._animsEnded = 0; |
| |
| var anims = arguments; |
| if(anims.length == 1 && (dojo.lang.isArray(anims[0]) || dojo.lang.isArrayLike(anims[0]))){ |
| /* animations: dojo.lfx.IAnimation[] |
| pId: a */ |
| anims = anims[0]; |
| } |
| |
| dojo.lang.forEach(anims, function(anim){ |
| this._anims.push(anim); |
| anim.connect("onEnd", dojo.lang.hitch(this, "_onAnimsEnded")); |
| }, this); |
| } |
| dojo.inherits(dojo.lfx.Combine, dojo.lfx.IAnimation); |
| dojo.lang.extend(dojo.lfx.Combine, { |
| // private members |
| _animsEnded: 0, |
| |
| // public methods |
| play: function(/*int?*/ delay, /*bool?*/ gotoStart){ |
| // summary: Start the animations. |
| // delay: How many milliseconds to delay before starting. |
| // gotoStart: If true, starts the animations from the beginning; otherwise, |
| // starts them from their current position. |
| if( !this._anims.length ){ return this; /*dojo.lfx.Combine*/} |
| |
| this.fire("beforeBegin"); |
| |
| if(delay > 0){ |
| setTimeout(dojo.lang.hitch(this, function(){ this.play(null, gotoStart); }), delay); |
| return this; // dojo.lfx.Combine |
| } |
| |
| if(gotoStart || this._anims[0].percent == 0){ |
| this.fire("onBegin"); |
| } |
| this.fire("onPlay"); |
| this._animsCall("play", null, gotoStart); |
| return this; // dojo.lfx.Combine |
| }, |
| |
| pause: function(){ |
| // summary: Pauses the running animations. |
| this.fire("onPause"); |
| this._animsCall("pause"); |
| return this; // dojo.lfx.Combine |
| }, |
| |
| stop: function(/*bool?*/ gotoEnd){ |
| // summary: Stops the running animations. |
| // gotoEnd: If true, the animations will end. |
| this.fire("onStop"); |
| this._animsCall("stop", gotoEnd); |
| return this; // dojo.lfx.Combine |
| }, |
| |
| // private methods |
| _onAnimsEnded: function(){ |
| this._animsEnded++; |
| if(this._animsEnded >= this._anims.length){ |
| this.fire("onEnd"); |
| } |
| return this; // dojo.lfx.Combine |
| }, |
| |
| _animsCall: function(/*String*/ funcName){ |
| var args = []; |
| if(arguments.length > 1){ |
| for(var i = 1 ; i < arguments.length ; i++){ |
| args.push(arguments[i]); |
| } |
| } |
| var _this = this; |
| dojo.lang.forEach(this._anims, function(anim){ |
| anim[funcName](args); |
| }, _this); |
| return this; // dojo.lfx.Combine |
| } |
| }); |
| |
| dojo.lfx.Chain = function(/*dojo.lfx.IAnimation...*/ animations) { |
| // summary: An animation object to play animations passed to it |
| // one after another. |
| dojo.lfx.IAnimation.call(this); |
| this._anims = []; |
| this._currAnim = -1; |
| |
| var anims = arguments; |
| if(anims.length == 1 && (dojo.lang.isArray(anims[0]) || dojo.lang.isArrayLike(anims[0]))){ |
| /* animations: dojo.lfx.IAnimation[] |
| pId: a */ |
| anims = anims[0]; |
| } |
| |
| var _this = this; |
| dojo.lang.forEach(anims, function(anim, i, anims_arr){ |
| this._anims.push(anim); |
| if(i < anims_arr.length - 1){ |
| anim.connect("onEnd", dojo.lang.hitch(this, "_playNext") ); |
| }else{ |
| anim.connect("onEnd", dojo.lang.hitch(this, function(){ this.fire("onEnd"); }) ); |
| } |
| }, this); |
| } |
| dojo.inherits(dojo.lfx.Chain, dojo.lfx.IAnimation); |
| dojo.lang.extend(dojo.lfx.Chain, { |
| // private members |
| _currAnim: -1, |
| |
| // public methods |
| play: function(/*int?*/ delay, /*bool?*/ gotoStart){ |
| // summary: Start the animation sequence. |
| // delay: How many milliseconds to delay before starting. |
| // gotoStart: If true, starts the sequence from the beginning; otherwise, |
| // starts it from its current position. |
| if( !this._anims.length ) { return this; /*dojo.lfx.Chain*/} |
| if( gotoStart || !this._anims[this._currAnim] ) { |
| this._currAnim = 0; |
| } |
| |
| var currentAnimation = this._anims[this._currAnim]; |
| |
| this.fire("beforeBegin"); |
| if(delay > 0){ |
| setTimeout(dojo.lang.hitch(this, function(){ this.play(null, gotoStart); }), delay); |
| return this; // dojo.lfx.Chain |
| } |
| |
| if(currentAnimation){ |
| if(this._currAnim == 0){ |
| this.fire("handler", ["begin", this._currAnim]); |
| this.fire("onBegin", [this._currAnim]); |
| } |
| this.fire("onPlay", [this._currAnim]); |
| currentAnimation.play(null, gotoStart); |
| } |
| return this; // dojo.lfx.Chain |
| }, |
| |
| pause: function(){ |
| // summary: Pauses the running animation sequence. |
| if( this._anims[this._currAnim] ) { |
| this._anims[this._currAnim].pause(); |
| this.fire("onPause", [this._currAnim]); |
| } |
| return this; // dojo.lfx.Chain |
| }, |
| |
| playPause: function(){ |
| // summary: If the animation sequence is playing, pause it; otherwise, |
| // play it. |
| if(this._anims.length == 0){ return this; } |
| if(this._currAnim == -1){ this._currAnim = 0; } |
| var currAnim = this._anims[this._currAnim]; |
| if( currAnim ) { |
| if( !currAnim._active || currAnim._paused ) { |
| this.play(); |
| } else { |
| this.pause(); |
| } |
| } |
| return this; // dojo.lfx.Chain |
| }, |
| |
| stop: function(){ |
| // summary: Stops the running animations. |
| var currAnim = this._anims[this._currAnim]; |
| if(currAnim){ |
| currAnim.stop(); |
| this.fire("onStop", [this._currAnim]); |
| } |
| return currAnim; // dojo.lfx.IAnimation |
| }, |
| |
| // private methods |
| _playNext: function(){ |
| if( this._currAnim == -1 || this._anims.length == 0 ) { return this; } |
| this._currAnim++; |
| if( this._anims[this._currAnim] ){ |
| this._anims[this._currAnim].play(null, true); |
| } |
| return this; // dojo.lfx.Chain |
| } |
| }); |
| |
| dojo.lfx.combine = function(/*dojo.lfx.IAnimation...*/ animations){ |
| // summary: Convenience function. Returns a dojo.lfx.Combine created |
| // using the animations passed in. |
| var anims = arguments; |
| if(dojo.lang.isArray(arguments[0])){ |
| /* animations: dojo.lfx.IAnimation[] |
| pId: a */ |
| anims = arguments[0]; |
| } |
| if(anims.length == 1){ return anims[0]; } |
| return new dojo.lfx.Combine(anims); // dojo.lfx.Combine |
| } |
| |
| dojo.lfx.chain = function(/*dojo.lfx.IAnimation...*/ animations){ |
| // summary: Convenience function. Returns a dojo.lfx.Chain created |
| // using the animations passed in. |
| var anims = arguments; |
| if(dojo.lang.isArray(arguments[0])){ |
| /* animations: dojo.lfx.IAnimation[] |
| pId: a */ |
| anims = arguments[0]; |
| } |
| if(anims.length == 1){ return anims[0]; } |
| return new dojo.lfx.Chain(anims); // dojo.lfx.Combine |
| } |
| |
| dojo.provide("dojo.html.common"); |
| |
| |
| |
| dojo.lang.mixin(dojo.html, dojo.dom); |
| |
| dojo.html.body = function(){ |
| dojo.deprecated("dojo.html.body() moved to dojo.body()", "0.5"); |
| return dojo.body(); |
| } |
| |
| // FIXME: we are going to assume that we can throw any and every rendering |
| // engine into the IE 5.x box model. In Mozilla, we do this w/ CSS. |
| // Need to investigate for KHTML and Opera |
| |
| dojo.html.getEventTarget = function(/* DOMEvent */evt){ |
| // summary |
| // Returns the target of an event |
| if(!evt) { evt = dojo.global().event || {} }; |
| var t = (evt.srcElement ? evt.srcElement : (evt.target ? evt.target : null)); |
| while((t)&&(t.nodeType!=1)){ t = t.parentNode; } |
| return t; // HTMLElement |
| } |
| |
| dojo.html.getViewport = function(){ |
| // summary |
| // Returns the dimensions of the viewable area of a browser window |
| var _window = dojo.global(); |
| var _document = dojo.doc(); |
| var w = 0; |
| var h = 0; |
| |
| if(dojo.render.html.mozilla){ |
| // mozilla |
| w = _document.documentElement.clientWidth; |
| h = _window.innerHeight; |
| }else if(!dojo.render.html.opera && _window.innerWidth){ |
| //in opera9, dojo.body().clientWidth should be used, instead |
| //of window.innerWidth/document.documentElement.clientWidth |
| //so we have to check whether it is opera |
| w = _window.innerWidth; |
| h = _window.innerHeight; |
| } else if (!dojo.render.html.opera && dojo.exists(_document, "documentElement.clientWidth")){ |
| // IE6 Strict |
| var w2 = _document.documentElement.clientWidth; |
| // this lets us account for scrollbars |
| if(!w || w2 && w2 < w) { |
| w = w2; |
| } |
| h = _document.documentElement.clientHeight; |
| } else if (dojo.body().clientWidth){ |
| // IE, Opera |
| w = dojo.body().clientWidth; |
| h = dojo.body().clientHeight; |
| } |
| return { width: w, height: h }; // object |
| } |
| |
| dojo.html.getScroll = function(){ |
| // summary |
| // Returns the scroll position of the document |
| var _window = dojo.global(); |
| var _document = dojo.doc(); |
| var top = _window.pageYOffset || _document.documentElement.scrollTop || dojo.body().scrollTop || 0; |
| var left = _window.pageXOffset || _document.documentElement.scrollLeft || dojo.body().scrollLeft || 0; |
| return { |
| top: top, |
| left: left, |
| offset:{ x: left, y: top } // note the change, NOT an Array with added properties. |
| }; // object |
| } |
| |
| dojo.html.getParentByType = function(/* HTMLElement */node, /* string */type) { |
| // summary |
| // Returns the first ancestor of node with tagName type. |
| var _document = dojo.doc(); |
| var parent = dojo.byId(node); |
| type = type.toLowerCase(); |
| while((parent)&&(parent.nodeName.toLowerCase()!=type)){ |
| if(parent==(_document["body"]||_document["documentElement"])){ |
| return null; |
| } |
| parent = parent.parentNode; |
| } |
| return parent; // HTMLElement |
| } |
| |
| dojo.html.getAttribute = function(/* HTMLElement */node, /* string */attr){ |
| // summary |
| // Returns the value of attribute attr from node. |
| node = dojo.byId(node); |
| // FIXME: need to add support for attr-specific accessors |
| if((!node)||(!node.getAttribute)){ |
| // if(attr !== 'nwType'){ |
| // alert("getAttr of '" + attr + "' with bad node"); |
| // } |
| return null; |
| } |
| var ta = typeof attr == 'string' ? attr : new String(attr); |
| |
| // first try the approach most likely to succeed |
| var v = node.getAttribute(ta.toUpperCase()); |
| if((v)&&(typeof v == 'string')&&(v!="")){ |
| return v; // string |
| } |
| |
| // try returning the attributes value, if we couldn't get it as a string |
| if(v && v.value){ |
| return v.value; // string |
| } |
| |
| // this should work on Opera 7, but it's a little on the crashy side |
| if((node.getAttributeNode)&&(node.getAttributeNode(ta))){ |
| return (node.getAttributeNode(ta)).value; // string |
| }else if(node.getAttribute(ta)){ |
| return node.getAttribute(ta); // string |
| }else if(node.getAttribute(ta.toLowerCase())){ |
| return node.getAttribute(ta.toLowerCase()); // string |
| } |
| return null; // string |
| } |
| |
| dojo.html.hasAttribute = function(/* HTMLElement */node, /* string */attr){ |
| // summary |
| // Determines whether or not the specified node carries a value for the attribute in question. |
| return dojo.html.getAttribute(dojo.byId(node), attr) ? true : false; // boolean |
| } |
| |
| dojo.html.getCursorPosition = function(/* DOMEvent */e){ |
| // summary |
| // Returns the mouse position relative to the document (not the viewport). |
| // For example, if you have a document that is 10000px tall, |
| // but your browser window is only 100px tall, |
| // if you scroll to the bottom of the document and call this function it |
| // will return {x: 0, y: 10000} |
| // NOTE: for events delivered via dojo.event.connect() and/or dojoAttachEvent (for widgets), |
| // you can just access evt.pageX and evt.pageY, rather than calling this function. |
| e = e || dojo.global().event; |
| var cursor = {x:0, y:0}; |
| if(e.pageX || e.pageY){ |
| cursor.x = e.pageX; |
| cursor.y = e.pageY; |
| }else{ |
| var de = dojo.doc().documentElement; |
| var db = dojo.body(); |
| cursor.x = e.clientX + ((de||db)["scrollLeft"]) - ((de||db)["clientLeft"]); |
| cursor.y = e.clientY + ((de||db)["scrollTop"]) - ((de||db)["clientTop"]); |
| } |
| return cursor; // object |
| } |
| |
| dojo.html.isTag = function(/* HTMLElement */node) { |
| // summary |
| // Like dojo.dom.isTag, except case-insensitive |
| node = dojo.byId(node); |
| if(node && node.tagName) { |
| for (var i=1; i<arguments.length; i++){ |
| if (node.tagName.toLowerCase()==String(arguments[i]).toLowerCase()){ |
| return String(arguments[i]).toLowerCase(); // string |
| } |
| } |
| } |
| return ""; // string |
| } |
| |
| //define dojo.html.createExternalElement for IE to workaround the annoying activation "feature" in new IE |
| //details: http://msdn.microsoft.com/library/default.asp?url=/workshop/author/dhtml/overview/activating_activex.asp |
| if(dojo.render.html.ie && !dojo.render.html.ie70){ |
| //only define createExternalElement for IE in none https to avoid "mixed content" warning dialog |
| if(window.location.href.substr(0,6).toLowerCase() != "https:"){ |
| (function(){ |
| // FIXME: this seems not to work correctly on IE 7!! |
| |
| //The trick is to define a function in a script.src property: |
| // <script src="javascript:'function createExternalElement(){...}'"></script>, |
| //which will be treated as an external javascript file in IE |
| var xscript = dojo.doc().createElement('script'); |
| xscript.src = "javascript:'dojo.html.createExternalElement=function(doc, tag){ return doc.createElement(tag); }'"; |
| dojo.doc().getElementsByTagName("head")[0].appendChild(xscript); |
| })(); |
| } |
| }else{ |
| //for other browsers, simply use document.createElement |
| //is enough |
| dojo.html.createExternalElement = function(/* HTMLDocument */doc, /* string */tag){ |
| // summary |
| // Creates an element in the HTML document, here for ActiveX activation workaround. |
| return doc.createElement(tag); // HTMLElement |
| } |
| } |
| |
| dojo.html._callDeprecated = function(inFunc, replFunc, args, argName, retValue){ |
| dojo.deprecated("dojo.html." + inFunc, |
| "replaced by dojo.html." + replFunc + "(" + (argName ? "node, {"+ argName + ": " + argName + "}" : "" ) + ")" + (retValue ? "." + retValue : ""), "0.5"); |
| var newArgs = []; |
| if(argName){ var argsIn = {}; argsIn[argName] = args[1]; newArgs.push(args[0]); newArgs.push(argsIn); } |
| else { newArgs = args } |
| var ret = dojo.html[replFunc].apply(dojo.html, args); |
| if(retValue){ return ret[retValue]; } |
| else { return ret; } |
| } |
| |
| dojo.html.getViewportWidth = function(){ |
| return dojo.html._callDeprecated("getViewportWidth", "getViewport", arguments, null, "width"); |
| } |
| dojo.html.getViewportHeight = function(){ |
| return dojo.html._callDeprecated("getViewportHeight", "getViewport", arguments, null, "height"); |
| } |
| dojo.html.getViewportSize = function(){ |
| return dojo.html._callDeprecated("getViewportSize", "getViewport", arguments); |
| } |
| dojo.html.getScrollTop = function(){ |
| return dojo.html._callDeprecated("getScrollTop", "getScroll", arguments, null, "top"); |
| } |
| dojo.html.getScrollLeft = function(){ |
| return dojo.html._callDeprecated("getScrollLeft", "getScroll", arguments, null, "left"); |
| } |
| dojo.html.getScrollOffset = function(){ |
| return dojo.html._callDeprecated("getScrollOffset", "getScroll", arguments, null, "offset"); |
| } |
| |
| dojo.provide("dojo.uri.Uri"); |
| |
| dojo.uri = new function() { |
| this.dojoUri = function (/*dojo.uri.Uri||String*/uri) { |
| // summary: returns a Uri object resolved relative to the dojo root |
| return new dojo.uri.Uri(dojo.hostenv.getBaseScriptUri(), uri); |
| } |
| |
| this.moduleUri = function(/*String*/module, /*dojo.uri.Uri||String*/uri){ |
| // summary: returns a Uri object relative to a module |
| // description: Examples: dojo.uri.moduleUri("dojo.widget","templates/template.html"), or dojo.uri.moduleUri("acme","images/small.png") |
| var loc = dojo.hostenv.getModuleSymbols(module).join('/'); |
| if(!loc){ |
| return null; |
| } |
| if(loc.lastIndexOf("/") != loc.length-1){ |
| loc += "/"; |
| } |
| |
| //If the path is an absolute path (starts with a / or is on another domain/xdomain) |
| //then don't add the baseScriptUri. |
| var colonIndex = loc.indexOf(":"); |
| var slashIndex = loc.indexOf("/"); |
| if(loc.charAt(0) != "/" && (colonIndex == -1 || colonIndex > slashIndex)){ |
| loc = dojo.hostenv.getBaseScriptUri() + loc; |
| } |
| |
| return new dojo.uri.Uri(loc,uri); |
| } |
| |
| this.Uri = function (/*dojo.uri.Uri||String...*/) { |
| // summary: Constructor to create an object representing a URI. |
| // description: |
| // Each argument is evaluated in order relative to the next until |
| // a canonical uri is produced. To get an absolute Uri relative |
| // to the current document use |
| // new dojo.uri.Uri(document.baseURI, uri) |
| |
| // TODO: support for IPv6, see RFC 2732 |
| |
| // resolve uri components relative to each other |
| var uri = arguments[0]; |
| for (var i = 1; i < arguments.length; i++) { |
| if(!arguments[i]) { continue; } |
| |
| // Safari doesn't support this.constructor so we have to be explicit |
| var relobj = new dojo.uri.Uri(arguments[i].toString()); |
| var uriobj = new dojo.uri.Uri(uri.toString()); |
| |
| if ((relobj.path=="")&&(relobj.scheme==null)&&(relobj.authority==null)&&(relobj.query==null)) { |
| if (relobj.fragment != null) { uriobj.fragment = relobj.fragment; } |
| relobj = uriobj; |
| } else if (relobj.scheme == null) { |
| relobj.scheme = uriobj.scheme; |
| |
| if (relobj.authority == null) { |
| relobj.authority = uriobj.authority; |
| |
| if (relobj.path.charAt(0) != "/") { |
| var path = uriobj.path.substring(0, |
| uriobj.path.lastIndexOf("/") + 1) + relobj.path; |
| |
| var segs = path.split("/"); |
| for (var j = 0; j < segs.length; j++) { |
| if (segs[j] == ".") { |
| if (j == segs.length - 1) { segs[j] = ""; } |
| else { segs.splice(j, 1); j--; } |
| } else if (j > 0 && !(j == 1 && segs[0] == "") && |
| segs[j] == ".." && segs[j-1] != "..") { |
| |
| if (j == segs.length - 1) { segs.splice(j, 1); segs[j - 1] = ""; } |
| else { segs.splice(j - 1, 2); j -= 2; } |
| } |
| } |
| relobj.path = segs.join("/"); |
| } |
| } |
| } |
| |
| uri = ""; |
| if (relobj.scheme != null) { uri += relobj.scheme + ":"; } |
| if (relobj.authority != null) { uri += "//" + relobj.authority; } |
| uri += relobj.path; |
| if (relobj.query != null) { uri += "?" + relobj.query; } |
| if (relobj.fragment != null) { uri += "#" + relobj.fragment; } |
| } |
| |
| this.uri = uri.toString(); |
| |
| // break the uri into its main components |
| var regexp = "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"; |
| var r = this.uri.match(new RegExp(regexp)); |
| |
| this.scheme = r[2] || (r[1] ? "" : null); |
| this.authority = r[4] || (r[3] ? "" : null); |
| this.path = r[5]; // can never be undefined |
| this.query = r[7] || (r[6] ? "" : null); |
| this.fragment = r[9] || (r[8] ? "" : null); |
| |
| if (this.authority != null) { |
| // server based naming authority |
| regexp = "^((([^:]+:)?([^@]+))@)?([^:]*)(:([0-9]+))?$"; |
| r = this.authority.match(new RegExp(regexp)); |
| |
| this.user = r[3] || null; |
| this.password = r[4] || null; |
| this.host = r[5]; |
| this.port = r[7] || null; |
| } |
| |
| this.toString = function(){ return this.uri; } |
| } |
| }; |
| |
| dojo.provide("dojo.html.style"); |
| |
| |
| |
| dojo.html.getClass = function(/* HTMLElement */node){ |
| // summary |
| // Returns the string value of the list of CSS classes currently assigned directly |
| // to the node in question. Returns an empty string if no class attribute is found; |
| node = dojo.byId(node); |
| if(!node){ return ""; } |
| var cs = ""; |
| if(node.className){ |
| cs = node.className; |
| }else if(dojo.html.hasAttribute(node, "class")){ |
| cs = dojo.html.getAttribute(node, "class"); |
| } |
| return cs.replace(/^\s+|\s+$/g, ""); // string |
| } |
| |
| dojo.html.getClasses = function(/* HTMLElement */node) { |
| // summary |
| // Returns an array of CSS classes currently assigned directly to the node in question. |
| // Returns an empty array if no classes are found; |
| var c = dojo.html.getClass(node); |
| return (c == "") ? [] : c.split(/\s+/g); // array |
| } |
| |
| dojo.html.hasClass = function(/* HTMLElement */node, /* string */classname){ |
| // summary |
| // Returns whether or not the specified classname is a portion of the |
| // class list currently applied to the node. Does not cover cascaded |
| // styles, only classes directly applied to the node. |
| return (new RegExp('(^|\\s+)'+classname+'(\\s+|$)')).test(dojo.html.getClass(node)) // boolean |
| } |
| |
| dojo.html.prependClass = function(/* HTMLElement */node, /* string */classStr){ |
| // summary |
| // Adds the specified class to the beginning of the class list on the |
| // passed node. This gives the specified class the highest precidence |
| // when style cascading is calculated for the node. Returns true or |
| // false; indicating success or failure of the operation, respectively. |
| classStr += " " + dojo.html.getClass(node); |
| return dojo.html.setClass(node, classStr); // boolean |
| } |
| |
| dojo.html.addClass = function(/* HTMLElement */node, /* string */classStr){ |
| // summary |
| // Adds the specified class to the end of the class list on the |
| // passed &node;. Returns &true; or &false; indicating success or failure. |
| if (dojo.html.hasClass(node, classStr)) { |
| return false; |
| } |
| classStr = (dojo.html.getClass(node) + " " + classStr).replace(/^\s+|\s+$/g,""); |
| return dojo.html.setClass(node, classStr); // boolean |
| } |
| |
| dojo.html.setClass = function(/* HTMLElement */node, /* string */classStr){ |
| // summary |
| // Clobbers the existing list of classes for the node, replacing it with |
| // the list given in the 2nd argument. Returns true or false |
| // indicating success or failure. |
| node = dojo.byId(node); |
| var cs = new String(classStr); |
| try{ |
| if(typeof node.className == "string"){ |
| node.className = cs; |
| }else if(node.setAttribute){ |
| node.setAttribute("class", classStr); |
| node.className = cs; |
| }else{ |
| return false; |
| } |
| }catch(e){ |
| dojo.debug("dojo.html.setClass() failed", e); |
| } |
| return true; |
| } |
| |
| dojo.html.removeClass = function(/* HTMLElement */node, /* string */classStr, /* boolean? */allowPartialMatches){ |
| // summary |
| // Removes the className from the node;. Returns true or false indicating success or failure. |
| try{ |
| if (!allowPartialMatches) { |
| var newcs = dojo.html.getClass(node).replace(new RegExp('(^|\\s+)'+classStr+'(\\s+|$)'), "$1$2"); |
| } else { |
| var newcs = dojo.html.getClass(node).replace(classStr,''); |
| } |
| dojo.html.setClass(node, newcs); |
| }catch(e){ |
| dojo.debug("dojo.html.removeClass() failed", e); |
| } |
| return true; // boolean |
| } |
| |
| dojo.html.replaceClass = function(/* HTMLElement */node, /* string */newClass, /* string */oldClass) { |
| // summary |
| // Replaces 'oldClass' and adds 'newClass' to node |
| dojo.html.removeClass(node, oldClass); |
| dojo.html.addClass(node, newClass); |
| } |
| |
| // Enum type for getElementsByClass classMatchType arg: |
| dojo.html.classMatchType = { |
| ContainsAll : 0, // all of the classes are part of the node's class (default) |
| ContainsAny : 1, // any of the classes are part of the node's class |
| IsOnly : 2 // only all of the classes are part of the node's class |
| } |
| |
| |
| dojo.html.getElementsByClass = function( |
| /* string */classStr, |
| /* HTMLElement? */parent, |
| /* string? */nodeType, |
| /* integer? */classMatchType, |
| /* boolean? */useNonXpath |
| ){ |
| // summary |
| // Returns an array of nodes for the given classStr, children of a |
| // parent, and optionally of a certain nodeType |
| // FIXME: temporarily set to false because of several dojo tickets related |
| // to the xpath version not working consistently in firefox. |
| useNonXpath = false; |
| var _document = dojo.doc(); |
| parent = dojo.byId(parent) || _document; |
| var classes = classStr.split(/\s+/g); |
| var nodes = []; |
| if( classMatchType != 1 && classMatchType != 2 ) classMatchType = 0; // make it enum |
| var reClass = new RegExp("(\\s|^)((" + classes.join(")|(") + "))(\\s|$)"); |
| var srtLength = classes.join(" ").length; |
| var candidateNodes = []; |
| |
| if(!useNonXpath && _document.evaluate) { // supports dom 3 xpath |
| var xpath = ".//" + (nodeType || "*") + "[contains("; |
| if(classMatchType != dojo.html.classMatchType.ContainsAny){ |
| xpath += "concat(' ',@class,' '), ' " + |
| classes.join(" ') and contains(concat(' ',@class,' '), ' ") + |
| " ')"; |
| if (classMatchType == 2) { |
| xpath += " and string-length(@class)="+srtLength+"]"; |
| }else{ |
| xpath += "]"; |
| } |
| }else{ |
| xpath += "concat(' ',@class,' '), ' " + |
| classes.join(" ') or contains(concat(' ',@class,' '), ' ") + |
| " ')]"; |
| } |
| var xpathResult = _document.evaluate(xpath, parent, null, XPathResult.ANY_TYPE, null); |
| var result = xpathResult.iterateNext(); |
| while(result){ |
| try{ |
| candidateNodes.push(result); |
| result = xpathResult.iterateNext(); |
| }catch(e){ break; } |
| } |
| return candidateNodes; // NodeList |
| }else{ |
| if(!nodeType){ |
| nodeType = "*"; |
| } |
| candidateNodes = parent.getElementsByTagName(nodeType); |
| |
| var node, i = 0; |
| outer: |
| while(node = candidateNodes[i++]){ |
| var nodeClasses = dojo.html.getClasses(node); |
| if(nodeClasses.length == 0){ continue outer; } |
| var matches = 0; |
| |
| for(var j = 0; j < nodeClasses.length; j++){ |
| if(reClass.test(nodeClasses[j])){ |
| if(classMatchType == dojo.html.classMatchType.ContainsAny){ |
| nodes.push(node); |
| continue outer; |
| }else{ |
| matches++; |
| } |
| }else{ |
| if(classMatchType == dojo.html.classMatchType.IsOnly){ |
| continue outer; |
| } |
| } |
| } |
| |
| if(matches == classes.length){ |
| if( (classMatchType == dojo.html.classMatchType.IsOnly)&& |
| (matches == nodeClasses.length)){ |
| nodes.push(node); |
| }else if(classMatchType == dojo.html.classMatchType.ContainsAll){ |
| nodes.push(node); |
| } |
| } |
| } |
| return nodes; // NodeList |
| } |
| } |
| dojo.html.getElementsByClassName = dojo.html.getElementsByClass; |
| |
| dojo.html.toCamelCase = function(/* string */selector){ |
| // summary |
| // Translates a CSS selector string to a camel-cased one. |
| var arr = selector.split('-'), cc = arr[0]; |
| for(var i = 1; i < arr.length; i++) { |
| cc += arr[i].charAt(0).toUpperCase() + arr[i].substring(1); |
| } |
| return cc; // string |
| } |
| |
| dojo.html.toSelectorCase = function(/* string */selector){ |
| // summary |
| // Translates a camel cased string to a selector cased one. |
| return selector.replace(/([A-Z])/g, "-$1" ).toLowerCase(); // string |
| } |
| |
| if (dojo.render.html.ie) { |
| // IE branch |
| dojo.html.getComputedStyle = function(/*HTMLElement|String*/node, /*String*/property, /*String*/value) { |
| // summary |
| // Get the computed style value for style "property" on "node" (IE). |
| node = dojo.byId(node); // FIXME: remove ability to access nodes by id for this time-critical function |
| if(!node || !node.currentStyle){return value;} |
| // FIXME: standardize on camel-case input to improve speed |
| return node.currentStyle[dojo.html.toCamelCase(property)]; // String |
| } |
| // SJM: getComputedStyle should be abandoned and replaced with the below function. |
| // All our supported browsers can return CSS2 compliant CssStyleDeclaration objects |
| // which can be queried directly for multiple styles. |
| dojo.html.getComputedStyles = function(/*HTMLElement*/node) { |
| // summary |
| // Get a style object containing computed styles for HTML Element node (IE). |
| return node.currentStyle; // CSSStyleDeclaration |
| } |
| } else { |
| // non-IE branch |
| dojo.html.getComputedStyle = function(/*HTMLElement|String*/node, /*String*/property, /*Any*/value) { |
| // summary |
| // Get the computed style value for style "property" on "node" (non-IE). |
| node = dojo.byId(node); |
| if(!node || !node.style){return value;} |
| var s = document.defaultView.getComputedStyle(node, null); |
| // s may be null on Safari |
| return (s&&s[dojo.html.toCamelCase(property)])||''; // String |
| } |
| // SJM: getComputedStyle should be abandoned and replaced with the below function. |
| // All our supported browsers can return CSS2 compliant CssStyleDeclaration objects |
| // which can be queried directly for multiple styles. |
| dojo.html.getComputedStyles = function(node) { |
| // summary |
| // Get a style object containing computed styles for HTML Element node (non-IE). |
| return document.defaultView.getComputedStyle(node, null); // CSSStyleDeclaration |
| } |
| } |
| |
| dojo.html.getStyleProperty = function(/* HTMLElement */node, /* string */cssSelector){ |
| // summary |
| // Returns the value of the passed style |
| node = dojo.byId(node); |
| return (node && node.style ? node.style[dojo.html.toCamelCase(cssSelector)] : undefined); // string |
| } |
| |
| dojo.html.getStyle = function(/* HTMLElement */node, /* string */cssSelector){ |
| // summary |
| // Returns the computed value of the passed style |
| var value = dojo.html.getStyleProperty(node, cssSelector); |
| return (value ? value : dojo.html.getComputedStyle(node, cssSelector)); // string || integer |
| } |
| |
| dojo.html.setStyle = function(/* HTMLElement */node, /* string */cssSelector, /* string */value){ |
| // summary |
| // Set the value of passed style on node |
| node = dojo.byId(node); |
| if(node && node.style){ |
| var camelCased = dojo.html.toCamelCase(cssSelector); |
| node.style[camelCased] = value; |
| } |
| } |
| |
| dojo.html.setStyleText = function (/* HTMLElement */target, /* string */text) { |
| // summary |
| // Try to set the entire cssText property of the passed target; equiv of setting style attribute. |
| try { |
| target.style.cssText = text; |
| } catch (e) { |
| target.setAttribute("style", text); |
| } |
| } |
| |
| dojo.html.copyStyle = function(/* HTMLElement */target, /* HTMLElement */source){ |
| // summary |
| // work around for opera which doesn't have cssText, and for IE which fails on setAttribute |
| if(!source.style.cssText){ |
| target.setAttribute("style", source.getAttribute("style")); |
| }else{ |
| target.style.cssText = source.style.cssText; |
| } |
| dojo.html.addClass(target, dojo.html.getClass(source)); |
| } |
| |
| dojo.html.getUnitValue = function(/* HTMLElement */node, /* string */cssSelector, /* boolean? */autoIsZero){ |
| // summary |
| // Get the value of passed selector, with the specific units used |
| var s = dojo.html.getComputedStyle(node, cssSelector); |
| if((!s)||((s == 'auto')&&(autoIsZero))){ |
| return { value: 0, units: 'px' }; // object |
| } |
| // FIXME: is regex inefficient vs. parseInt or some manual test? |
| var match = s.match(/(\-?[\d.]+)([a-z%]*)/i); |
| if (!match){return dojo.html.getUnitValue.bad;} |
| return { value: Number(match[1]), units: match[2].toLowerCase() }; // object |
| } |
| dojo.html.getUnitValue.bad = { value: NaN, units: '' }; |
| |
| if (dojo.render.html.ie) { |
| // IE branch |
| dojo.html.toPixelValue = function(/* HTMLElement */element, /* String */styleValue){ |
| // summary |
| // Extract value in pixels from styleValue (IE version). |
| // If a value cannot be extracted, zero is returned. |
| if(!styleValue){return 0;} |
| if(styleValue.slice(-2) == 'px'){return parseFloat(styleValue);} |
| var pixelValue = 0; |
| with(element){ |
| var sLeft = style.left; |
| var rsLeft = runtimeStyle.left; |
| runtimeStyle.left = currentStyle.left; |
| try { |
| style.left = styleValue || 0; |
| pixelValue = style.pixelLeft; |
| style.left = sLeft; |
| runtimeStyle.left = rsLeft; |
| }catch(e){ |
| // FIXME: it's possible for styleValue to be incompatible with |
| // style.left. In particular, border width values of |
| // "thick", "medium", or "thin" will provoke an exception. |
| } |
| } |
| return pixelValue; // Number |
| } |
| } else { |
| // non-IE branch |
| dojo.html.toPixelValue = function(/* HTMLElement */element, /* String */styleValue){ |
| // summary |
| // Extract value in pixels from styleValue (non-IE version). |
| // If a value cannot be extracted, zero is returned. |
| return (styleValue && (styleValue.slice(-2)=='px') ? parseFloat(styleValue) : 0); // Number |
| } |
| } |
| |
| dojo.html.getPixelValue = function(/* HTMLElement */node, /* string */styleProperty, /* boolean? */autoIsZero){ |
| // summary |
| // Get a computed style value, in pixels. |
| // node: HTMLElement |
| // Node to interrogate |
| // styleProperty: String |
| // Style property to query, in either css-selector or camelCase (property) format. |
| // autoIsZero: Boolean |
| // Deprecated. Any value that cannot be converted to pixels is returned as zero. |
| // |
| // summary |
| // Get the value of passed selector in pixels. |
| // |
| return dojo.html.toPixelValue(node, dojo.html.getComputedStyle(node, styleProperty)); |
| } |
| |
| dojo.html.setPositivePixelValue = function(/* HTMLElement */node, /* string */selector, /* integer */value){ |
| // summary |
| // Attempt to set the value of selector on node as a positive pixel value. |
| if(isNaN(value)){return false;} |
| node.style[selector] = Math.max(0, value) + 'px'; |
| return true; // boolean |
| } |
| |
| dojo.html.styleSheet = null; |
| |
| // FIXME: this is a really basic stub for adding and removing cssRules, but |
| // it assumes that you know the index of the cssRule that you want to add |
| // or remove, making it less than useful. So we need something that can |
| // search for the selector that you you want to remove. |
| dojo.html.insertCssRule = function(/* string */selector, /* string */declaration, /* integer? */index) { |
| // summary |
| // Attempt to insert declaration as selector on the internal stylesheet; if index try to set it there. |
| if (!dojo.html.styleSheet) { |
| if (document.createStyleSheet) { // IE |
| dojo.html.styleSheet = document.createStyleSheet(); |
| } else if (document.styleSheets[0]) { // rest |
| // FIXME: should create a new style sheet here |
| // fall back on an exsiting style sheet |
| dojo.html.styleSheet = document.styleSheets[0]; |
| } else { |
| return null; // integer |
| } // fail |
| } |
| |
| if (arguments.length < 3) { // index may == 0 |
| if (dojo.html.styleSheet.cssRules) { // W3 |
| index = dojo.html.styleSheet.cssRules.length; |
| } else if (dojo.html.styleSheet.rules) { // IE |
| index = dojo.html.styleSheet.rules.length; |
| } else { |
| return null; // integer |
| } // fail |
| } |
| |
| if (dojo.html.styleSheet.insertRule) { // W3 |
| var rule = selector + " { " + declaration + " }"; |
| return dojo.html.styleSheet.insertRule(rule, index); // integer |
| } else if (dojo.html.styleSheet.addRule) { // IE |
| return dojo.html.styleSheet.addRule(selector, declaration, index); // integer |
| } else { |
| return null; // integer |
| } // fail |
| } |
| |
| dojo.html.removeCssRule = function(/* integer? */index){ |
| // summary |
| // Attempt to remove the rule at index. |
| if(!dojo.html.styleSheet){ |
| dojo.debug("no stylesheet defined for removing rules"); |
| return false; |
| } |
| if(dojo.render.html.ie){ |
| if(!index){ |
| index = dojo.html.styleSheet.rules.length; |
| dojo.html.styleSheet.removeRule(index); |
| } |
| }else if(document.styleSheets[0]){ |
| if(!index){ |
| index = dojo.html.styleSheet.cssRules.length; |
| } |
| dojo.html.styleSheet.deleteRule(index); |
| } |
| return true; // boolean |
| } |
| |
| dojo.html._insertedCssFiles = []; // cache container needed because IE reformats cssText when added to DOM |
| dojo.html.insertCssFile = function(/* string */URI, /* HTMLDocument? */doc, /* boolean? */checkDuplicates, /* boolean */fail_ok){ |
| // summary |
| // calls css by XmlHTTP and inserts it into DOM as <style [widgetType="widgetType"]> *downloaded cssText*</style> |
| if(!URI){ return; } |
| if(!doc){ doc = document; } |
| var cssStr = dojo.hostenv.getText(URI, false, fail_ok); |
| if(cssStr===null){ return; } |
| cssStr = dojo.html.fixPathsInCssText(cssStr, URI); |
| |
| if(checkDuplicates){ |
| var idx = -1, node, ent = dojo.html._insertedCssFiles; |
| for(var i = 0; i < ent.length; i++){ |
| if((ent[i].doc == doc) && (ent[i].cssText == cssStr)){ |
| idx = i; node = ent[i].nodeRef; |
| break; |
| } |
| } |
| // make sure we havent deleted our node |
| if(node){ |
| var styles = doc.getElementsByTagName("style"); |
| for(var i = 0; i < styles.length; i++){ |
| if(styles[i] == node){ |
| return; |
| } |
| } |
| // delete this entry |
| dojo.html._insertedCssFiles.shift(idx, 1); |
| } |
| } |
| |
| var style = dojo.html.insertCssText(cssStr, doc); |
| dojo.html._insertedCssFiles.push({'doc': doc, 'cssText': cssStr, 'nodeRef': style}); |
| |
| // insert custom attribute ex dbgHref="../foo.css" usefull when debugging in DOM inspectors, no? |
| if(style && djConfig.isDebug){ |
| style.setAttribute("dbgHref", URI); |
| } |
| return style; // HTMLStyleElement |
| } |
| |
| dojo.html.insertCssText = function(/* string */cssStr, /* HTMLDocument? */doc, /* string? */URI){ |
| // summary |
| // Attempt to insert CSS rules into the document through inserting a style element |
| // DomNode Style = insertCssText(String ".dojoMenu {color: green;}"[, DomDoc document, dojo.uri.Uri Url ]) |
| if(!cssStr){ |
| return; // HTMLStyleElement |
| } |
| if(!doc){ doc = document; } |
| if(URI){// fix paths in cssStr |
| cssStr = dojo.html.fixPathsInCssText(cssStr, URI); |
| } |
| var style = doc.createElement("style"); |
| style.setAttribute("type", "text/css"); |
| // IE is b0rken enough to require that we add the element to the doc |
| // before changing it's properties |
| var head = doc.getElementsByTagName("head")[0]; |
| if(!head){ // must have a head tag |
| dojo.debug("No head tag in document, aborting styles"); |
| return; // HTMLStyleElement |
| }else{ |
| head.appendChild(style); |
| } |
| if(style.styleSheet){// IE |
| var setFunc = function(){ |
| try{ |
| style.styleSheet.cssText = cssStr; |
| }catch(e){ dojo.debug(e); } |
| }; |
| if(style.styleSheet.disabled){ |
| setTimeout(setFunc, 10); |
| }else{ |
| setFunc(); |
| } |
| }else{ // w3c |
| var cssText = doc.createTextNode(cssStr); |
| style.appendChild(cssText); |
| } |
| return style; // HTMLStyleElement |
| } |
| |
| dojo.html.fixPathsInCssText = function(/* string */cssStr, /* string */URI){ |
| // summary |
| // usage: cssText comes from dojoroot/src/widget/templates/Foobar.css |
| // it has .dojoFoo { background-image: url(images/bar.png);} then uri should point to dojoroot/src/widget/templates/ |
| if(!cssStr || !URI){ return; } |
| var match, str = "", url = "", urlChrs = "[\\t\\s\\w\\(\\)\\/\\.\\\\'\"-:#=&?~]+"; |
| var regex = new RegExp('url\\(\\s*('+urlChrs+')\\s*\\)'); |
| var regexProtocol = /(file|https?|ftps?):\/\//; |
| regexTrim = new RegExp("^[\\s]*(['\"]?)("+urlChrs+")\\1[\\s]*?$"); |
| if(dojo.render.html.ie55 || dojo.render.html.ie60){ |
| var regexIe = new RegExp("AlphaImageLoader\\((.*)src\=['\"]("+urlChrs+")['\"]"); |
| // TODO: need to decide how to handle relative paths and AlphaImageLoader see #1441 |
| // current implementation breaks on build with intern_strings |
| while(match = regexIe.exec(cssStr)){ |
| url = match[2].replace(regexTrim, "$2"); |
| if(!regexProtocol.exec(url)){ |
| url = (new dojo.uri.Uri(URI, url).toString()); |
| } |
| str += cssStr.substring(0, match.index) + "AlphaImageLoader(" + match[1] + "src='" + url + "'"; |
| cssStr = cssStr.substr(match.index + match[0].length); |
| } |
| cssStr = str + cssStr; |
| str = ""; |
| } |
| |
| while(match = regex.exec(cssStr)){ |
| url = match[1].replace(regexTrim, "$2"); |
| if(!regexProtocol.exec(url)){ |
| url = (new dojo.uri.Uri(URI, url).toString()); |
| } |
| str += cssStr.substring(0, match.index) + "url(" + url + ")"; |
| cssStr = cssStr.substr(match.index + match[0].length); |
| } |
| return str + cssStr; // string |
| } |
| |
| dojo.html.setActiveStyleSheet = function(/* string */title){ |
| // summary |
| // Activate style sheet with specified title. |
| var i = 0, a, els = dojo.doc().getElementsByTagName("link"); |
| while (a = els[i++]) { |
| if(a.getAttribute("rel").indexOf("style") != -1 && a.getAttribute("title")){ |
| a.disabled = true; |
| if (a.getAttribute("title") == title) { a.disabled = false; } |
| } |
| } |
| } |
| |
| dojo.html.getActiveStyleSheet = function(){ |
| // summary |
| // return the title of the currently active stylesheet |
| var i = 0, a, els = dojo.doc().getElementsByTagName("link"); |
| while (a = els[i++]) { |
| if (a.getAttribute("rel").indexOf("style") != -1 |
| && a.getAttribute("title") |
| && !a.disabled |
| ){ |
| return a.getAttribute("title"); // string |
| } |
| } |
| return null; // string |
| } |
| |
| dojo.html.getPreferredStyleSheet = function(){ |
| // summary |
| // Return the preferred stylesheet title (i.e. link without alt attribute) |
| var i = 0, a, els = dojo.doc().getElementsByTagName("link"); |
| while (a = els[i++]) { |
| if(a.getAttribute("rel").indexOf("style") != -1 |
| && a.getAttribute("rel").indexOf("alt") == -1 |
| && a.getAttribute("title") |
| ){ |
| return a.getAttribute("title"); // string |
| } |
| } |
| return null; // string |
| } |
| |
| dojo.html.applyBrowserClass = function(/* HTMLElement */node){ |
| // summary |
| // Applies pre-set class names based on browser & version to the passed node. |
| // Modified version of Morris' CSS hack. |
| var drh=dojo.render.html; |
| var classes = { |
| dj_ie: drh.ie, |
| dj_ie55: drh.ie55, |
| dj_ie6: drh.ie60, |
| dj_ie7: drh.ie70, |
| dj_iequirks: drh.ie && drh.quirks, |
| dj_opera: drh.opera, |
| dj_opera8: drh.opera && (Math.floor(dojo.render.version)==8), |
| dj_opera9: drh.opera && (Math.floor(dojo.render.version)==9), |
| dj_khtml: drh.khtml, |
| dj_safari: drh.safari, |
| dj_gecko: drh.mozilla |
| }; // no dojo unsupported browsers |
| for(var p in classes){ |
| if(classes[p]){ |
| dojo.html.addClass(node, p); |
| } |
| } |
| }; |
| |
| dojo.provide("dojo.html.display"); |
| |
| |
| dojo.html._toggle = function(node, tester, setter){ |
| node = dojo.byId(node); |
| setter(node, !tester(node)); |
| return tester(node); |
| } |
| |
| dojo.html.show = function(/* HTMLElement */node){ |
| // summary |
| // Show the passed element by reverting display property set by dojo.html.hide |
| node = dojo.byId(node); |
| if(dojo.html.getStyleProperty(node, 'display')=='none'){ |
| dojo.html.setStyle(node, 'display', (node.dojoDisplayCache||'')); |
| node.dojoDisplayCache = undefined; // cannot use delete on a node in IE6 |
| } |
| } |
| |
| dojo.html.hide = function(/* HTMLElement */node){ |
| // summary |
| // Hide the passed element by setting display:none |
| node = dojo.byId(node); |
| if(typeof node["dojoDisplayCache"] == "undefined"){ // it could == '', so we cannot say !node.dojoDisplayCount |
| var d = dojo.html.getStyleProperty(node, 'display') |
| if(d!='none'){ |
| node.dojoDisplayCache = d; |
| } |
| } |
| dojo.html.setStyle(node, 'display', 'none'); |
| } |
| |
| dojo.html.setShowing = function(/* HTMLElement */node, /* boolean? */showing){ |
| // summary |
| // Calls show() if showing is true, hide() otherwise |
| dojo.html[(showing ? 'show' : 'hide')](node); |
| } |
| |
| dojo.html.isShowing = function(/* HTMLElement */node){ |
| // summary |
| // Returns whether the element is displayed or not. |
| // FIXME: returns true if node is bad, isHidden would be easier to make correct |
| return (dojo.html.getStyleProperty(node, 'display') != 'none'); // boolean |
| } |
| |
| dojo.html.toggleShowing = function(/* HTMLElement */node){ |
| // summary |
| // Call setShowing() on node with the complement of isShowing(), then return the new value of isShowing() |
| return dojo.html._toggle(node, dojo.html.isShowing, dojo.html.setShowing); // boolean |
| } |
| |
| // Simple mapping of tag names to display values |
| // FIXME: simplistic |
| dojo.html.displayMap = { tr: '', td: '', th: '', img: 'inline', span: 'inline', input: 'inline', button: 'inline' }; |
| |
| dojo.html.suggestDisplayByTagName = function(/* HTMLElement */node){ |
| // summary |
| // Suggest a value for the display property that will show 'node' based on it's tag |
| node = dojo.byId(node); |
| if(node && node.tagName){ |
| var tag = node.tagName.toLowerCase(); |
| return (tag in dojo.html.displayMap ? dojo.html.displayMap[tag] : 'block'); // string |
| } |
| } |
| |
| dojo.html.setDisplay = function(/* HTMLElement */node, /* string */display){ |
| // summary |
| // Sets the value of style.display to value of 'display' parameter if it is a string. |
| // Otherwise, if 'display' is false, set style.display to 'none'. |
| // Finally, set 'display' to a suggested display value based on the node's tag |
| dojo.html.setStyle(node, 'display', ((display instanceof String || typeof display == "string") ? display : (display ? dojo.html.suggestDisplayByTagName(node) : 'none'))); |
| } |
| |
| dojo.html.isDisplayed = function(/* HTMLElement */node){ |
| // summary |
| // Is true if the the computed display style for node is not 'none' |
| // FIXME: returns true if node is bad, isNotDisplayed would be easier to make correct |
| return (dojo.html.getComputedStyle(node, 'display') != 'none'); // boolean |
| } |
| |
| dojo.html.toggleDisplay = function(/* HTMLElement */node){ |
| // summary |
| // Call setDisplay() on node with the complement of isDisplayed(), then |
| // return the new value of isDisplayed() |
| return dojo.html._toggle(node, dojo.html.isDisplayed, dojo.html.setDisplay); // boolean |
| } |
| |
| dojo.html.setVisibility = function(/* HTMLElement */node, /* string */visibility){ |
| // summary |
| // Sets the value of style.visibility to value of 'visibility' parameter if it is a string. |
| // Otherwise, if 'visibility' is false, set style.visibility to 'hidden'. Finally, set style.visibility to 'visible'. |
| dojo.html.setStyle(node, 'visibility', ((visibility instanceof String || typeof visibility == "string") ? visibility : (visibility ? 'visible' : 'hidden'))); |
| } |
| |
| dojo.html.isVisible = function(/* HTMLElement */node){ |
| // summary |
| // Returns true if the the computed visibility style for node is not 'hidden' |
| // FIXME: returns true if node is bad, isInvisible would be easier to make correct |
| return (dojo.html.getComputedStyle(node, 'visibility') != 'hidden'); // boolean |
| } |
| |
| dojo.html.toggleVisibility = function(node){ |
| // summary |
| // Call setVisibility() on node with the complement of isVisible(), then return the new value of isVisible() |
| return dojo.html._toggle(node, dojo.html.isVisible, dojo.html.setVisibility); // boolean |
| } |
| |
| dojo.html.setOpacity = function(/* HTMLElement */node, /* float */opacity, /* boolean? */dontFixOpacity){ |
| // summary |
| // Sets the opacity of node in a cross-browser way. |
| // float between 0.0 (transparent) and 1.0 (opaque) |
| node = dojo.byId(node); |
| var h = dojo.render.html; |
| if(!dontFixOpacity){ |
| if( opacity >= 1.0){ |
| if(h.ie){ |
| dojo.html.clearOpacity(node); |
| return; |
| }else{ |
| opacity = 0.999999; |
| } |
| }else if( opacity < 0.0){ opacity = 0; } |
| } |
| if(h.ie){ |
| if(node.nodeName.toLowerCase() == "tr"){ |
| // FIXME: is this too naive? will we get more than we want? |
| var tds = node.getElementsByTagName("td"); |
| for(var x=0; x<tds.length; x++){ |
| tds[x].style.filter = "Alpha(Opacity="+opacity*100+")"; |
| } |
| } |
| node.style.filter = "Alpha(Opacity="+opacity*100+")"; |
| }else if(h.moz){ |
| node.style.opacity = opacity; // ffox 1.0 directly supports "opacity" |
| node.style.MozOpacity = opacity; |
| }else if(h.safari){ |
| node.style.opacity = opacity; // 1.3 directly supports "opacity" |
| node.style.KhtmlOpacity = opacity; |
| }else{ |
| node.style.opacity = opacity; |
| } |
| } |
| |
| dojo.html.clearOpacity = function(/* HTMLElement */node){ |
| // summary |
| // Clears any opacity setting on the passed element. |
| node = dojo.byId(node); |
| var ns = node.style; |
| var h = dojo.render.html; |
| if(h.ie){ |
| try { |
| if( node.filters && node.filters.alpha ){ |
| ns.filter = ""; // FIXME: may get rid of other filter effects |
| } |
| } catch(e) { |
| /* |
| * IE7 gives error if node.filters not set; |
| * don't know why or how to workaround (other than this) |
| */ |
| } |
| }else if(h.moz){ |
| ns.opacity = 1; |
| ns.MozOpacity = 1; |
| }else if(h.safari){ |
| ns.opacity = 1; |
| ns.KhtmlOpacity = 1; |
| }else{ |
| ns.opacity = 1; |
| } |
| } |
| |
| dojo.html.getOpacity = function(/* HTMLElement */node){ |
| // summary |
| // Returns the opacity of the passed element |
| node = dojo.byId(node); |
| var h = dojo.render.html; |
| if(h.ie){ |
| var opac = (node.filters && node.filters.alpha && |
| typeof node.filters.alpha.opacity == "number" |
| ? node.filters.alpha.opacity : 100) / 100; |
| }else{ |
| var opac = node.style.opacity || node.style.MozOpacity || |
| node.style.KhtmlOpacity || 1; |
| } |
| return opac >= 0.999999 ? 1.0 : Number(opac); // float |
| } |
| |
| |
| dojo.provide("dojo.html.color"); |
| |
| |
| |
| |
| dojo.html.getBackgroundColor = function(/* HTMLElement */node){ |
| // summary |
| // returns the background color of the passed node as a 32-bit color (RGBA) |
| node = dojo.byId(node); |
| var color; |
| do{ |
| color = dojo.html.getStyle(node, "background-color"); |
| // Safari doesn't say "transparent" |
| if(color.toLowerCase() == "rgba(0, 0, 0, 0)") { color = "transparent"; } |
| if(node == document.getElementsByTagName("body")[0]) { node = null; break; } |
| node = node.parentNode; |
| }while(node && dojo.lang.inArray(["transparent", ""], color)); |
| if(color == "transparent"){ |
| color = [255, 255, 255, 0]; |
| }else{ |
| color = dojo.gfx.color.extractRGB(color); |
| } |
| return color; // array |
| } |
| |
| dojo.provide("dojo.html.layout"); |
| |
| |
| |
| |
| |
| dojo.html.sumAncestorProperties = function(/* HTMLElement */node, /* string */prop){ |
| // summary |
| // Returns the sum of the passed property on all ancestors of node. |
| node = dojo.byId(node); |
| if(!node){ return 0; } // FIXME: throw an error? |
| |
| var retVal = 0; |
| while(node){ |
| if(dojo.html.getComputedStyle(node, 'position') == 'fixed'){ |
| return 0; |
| } |
| var val = node[prop]; |
| if(val){ |
| retVal += val - 0; |
| if(node==dojo.body()){ break; }// opera and khtml #body & #html has the same values, we only need one value |
| } |
| node = node.parentNode; |
| } |
| return retVal; // integer |
| } |
| |
| dojo.html.setStyleAttributes = function(/* HTMLElement */node, /* string */attributes) { |
| // summary |
| // allows a dev to pass a string similar to what you'd pass in style="", and apply it to a node. |
| node = dojo.byId(node); |
| var splittedAttribs=attributes.replace(/(;)?\s*$/, "").split(";"); |
| for(var i=0; i<splittedAttribs.length; i++){ |
| var nameValue=splittedAttribs[i].split(":"); |
| var name=nameValue[0].replace(/\s*$/, "").replace(/^\s*/, "").toLowerCase(); |
| var value=nameValue[1].replace(/\s*$/, "").replace(/^\s*/, ""); |
| switch(name){ |
| case "opacity": |
| dojo.html.setOpacity(node, value); |
| break; |
| case "content-height": |
| dojo.html.setContentBox(node, {height: value}); |
| break; |
| case "content-width": |
| dojo.html.setContentBox(node, {width: value}); |
| break; |
| case "outer-height": |
| dojo.html.setMarginBox(node, {height: value}); |
| break; |
| case "outer-width": |
| dojo.html.setMarginBox(node, {width: value}); |
| break; |
| default: |
| node.style[dojo.html.toCamelCase(name)]=value; |
| } |
| } |
| } |
| |
| dojo.html.boxSizing = { |
| MARGIN_BOX: "margin-box", |
| BORDER_BOX: "border-box", |
| PADDING_BOX: "padding-box", |
| CONTENT_BOX: "content-box" |
| }; |
| |
| dojo.html.getAbsolutePosition = dojo.html.abs = function(/* HTMLElement */node, /* boolean? */includeScroll, /* string? */boxType){ |
| // summary |
| // Gets the absolute position of the passed element based on the document itself. |
| node = dojo.byId(node, node.ownerDocument); |
| var ret = { |
| x: 0, |
| y: 0 |
| }; |
| |
| var bs = dojo.html.boxSizing; |
| if(!boxType) { boxType = bs.CONTENT_BOX; } |
| var nativeBoxType = 2; //BORDER box |
| var targetBoxType; |
| switch(boxType){ |
| case bs.MARGIN_BOX: |
| targetBoxType = 3; |
| break; |
| case bs.BORDER_BOX: |
| targetBoxType = 2; |
| break; |
| case bs.PADDING_BOX: |
| default: |
| targetBoxType = 1; |
| break; |
| case bs.CONTENT_BOX: |
| targetBoxType = 0; |
| break; |
| } |
| |
| var h = dojo.render.html; |
| var db = document["body"]||document["documentElement"]; |
| |
| if(h.ie){ |
| with(node.getBoundingClientRect()){ |
| ret.x = left-2; |
| ret.y = top-2; |
| } |
| }else if(document.getBoxObjectFor){ |
| // mozilla |
| nativeBoxType = 1; //getBoxObjectFor return padding box coordinate |
| try{ |
| var bo = document.getBoxObjectFor(node); |
| ret.x = bo.x - dojo.html.sumAncestorProperties(node, "scrollLeft"); |
| ret.y = bo.y - dojo.html.sumAncestorProperties(node, "scrollTop"); |
| }catch(e){ |
| // squelch |
| } |
| }else{ |
| if(node["offsetParent"]){ |
| var endNode; |
| // in Safari, if the node is an absolutely positioned child of |
| // the body and the body has a margin the offset of the child |
| // and the body contain the body's margins, so we need to end |
| // at the body |
| if( (h.safari)&& |
| (node.style.getPropertyValue("position") == "absolute")&& |
| (node.parentNode == db)){ |
| endNode = db; |
| }else{ |
| endNode = db.parentNode; |
| } |
| |
| //TODO: set correct nativeBoxType for safari/konqueror |
| |
| if(node.parentNode != db){ |
| var nd = node; |
| if(dojo.render.html.opera){ nd = db; } |
| ret.x -= dojo.html.sumAncestorProperties(nd, "scrollLeft"); |
| ret.y -= dojo.html.sumAncestorProperties(nd, "scrollTop"); |
| } |
| var curnode = node; |
| do{ |
| var n = curnode["offsetLeft"]; |
| //FIXME: ugly hack to workaround the submenu in |
| //popupmenu2 does not shown up correctly in opera. |
| //Someone have a better workaround? |
| if(!h.opera || n>0){ |
| ret.x += isNaN(n) ? 0 : n; |
| } |
| var m = curnode["offsetTop"]; |
| ret.y += isNaN(m) ? 0 : m; |
| curnode = curnode.offsetParent; |
| }while((curnode != endNode)&&(curnode != null)); |
| }else if(node["x"]&&node["y"]){ |
| ret.x += isNaN(node.x) ? 0 : node.x; |
| ret.y += isNaN(node.y) ? 0 : node.y; |
| } |
| } |
| |
| // account for document scrolling! |
| if(includeScroll){ |
| var scroll = dojo.html.getScroll(); |
| ret.y += scroll.top; |
| ret.x += scroll.left; |
| } |
| |
| var extentFuncArray=[dojo.html.getPaddingExtent, dojo.html.getBorderExtent, dojo.html.getMarginExtent]; |
| if(nativeBoxType > targetBoxType){ |
| for(var i=targetBoxType;i<nativeBoxType;++i){ |
| ret.y += extentFuncArray[i](node, 'top'); |
| ret.x += extentFuncArray[i](node, 'left'); |
| } |
| }else if(nativeBoxType < targetBoxType){ |
| for(var i=targetBoxType;i>nativeBoxType;--i){ |
| ret.y -= extentFuncArray[i-1](node, 'top'); |
| ret.x -= extentFuncArray[i-1](node, 'left'); |
| } |
| } |
| ret.top = ret.y; |
| ret.left = ret.x; |
| return ret; // object |
| } |
| |
| dojo.html.isPositionAbsolute = function(/* HTMLElement */node){ |
| // summary |
| // Returns true if the element is absolutely positioned. |
| return (dojo.html.getComputedStyle(node, 'position') == 'absolute'); // boolean |
| } |
| |
| dojo.html._sumPixelValues = function(/* HTMLElement */node, selectors, autoIsZero){ |
| var total = 0; |
| for(var x=0; x<selectors.length; x++){ |
| total += dojo.html.getPixelValue(node, selectors[x], autoIsZero); |
| } |
| return total; |
| } |
| |
| dojo.html.getMargin = function(/* HTMLElement */node){ |
| // summary |
| // Returns the width and height of the passed node's margin |
| return { |
| width: dojo.html._sumPixelValues(node, ["margin-left", "margin-right"], (dojo.html.getComputedStyle(node, 'position') == 'absolute')), |
| height: dojo.html._sumPixelValues(node, ["margin-top", "margin-bottom"], (dojo.html.getComputedStyle(node, 'position') == 'absolute')) |
| }; // object |
| } |
| |
| dojo.html.getBorder = function(/* HTMLElement */node){ |
| // summary |
| // Returns the width and height of the passed node's border |
| return { |
| width: dojo.html.getBorderExtent(node, 'left') + dojo.html.getBorderExtent(node, 'right'), |
| height: dojo.html.getBorderExtent(node, 'top') + dojo.html.getBorderExtent(node, 'bottom') |
| }; // object |
| } |
| |
| dojo.html.getBorderExtent = function(/* HTMLElement */node, /* string */side){ |
| // summary |
| // returns the width of the requested border |
| return (dojo.html.getStyle(node, 'border-' + side + '-style') == 'none' ? 0 : dojo.html.getPixelValue(node, 'border-' + side + '-width')); // integer |
| } |
| |
| dojo.html.getMarginExtent = function(/* HTMLElement */node, /* string */side){ |
| // summary |
| // returns the width of the requested margin |
| return dojo.html._sumPixelValues(node, ["margin-" + side], dojo.html.isPositionAbsolute(node)); // integer |
| } |
| |
| dojo.html.getPaddingExtent = function(/* HTMLElement */node, /* string */side){ |
| // summary |
| // Returns the width of the requested padding |
| return dojo.html._sumPixelValues(node, ["padding-" + side], true); // integer |
| } |
| |
| dojo.html.getPadding = function(/* HTMLElement */node){ |
| // summary |
| // Returns the width and height of the passed node's padding |
| return { |
| width: dojo.html._sumPixelValues(node, ["padding-left", "padding-right"], true), |
| height: dojo.html._sumPixelValues(node, ["padding-top", "padding-bottom"], true) |
| }; // object |
| } |
| |
| dojo.html.getPadBorder = function(/* HTMLElement */node){ |
| // summary |
| // Returns the width and height of the passed node's padding and border |
| var pad = dojo.html.getPadding(node); |
| var border = dojo.html.getBorder(node); |
| return { width: pad.width + border.width, height: pad.height + border.height }; // object |
| } |
| |
| dojo.html.getBoxSizing = function(/* HTMLElement */node){ |
| // summary |
| // Returns which box model the passed element is working with |
| var h = dojo.render.html; |
| var bs = dojo.html.boxSizing; |
| if(((h.ie)||(h.opera)) && node.nodeName.toLowerCase() != "img"){ |
| var cm = document["compatMode"]; |
| if((cm == "BackCompat")||(cm == "QuirksMode")){ |
| return bs.BORDER_BOX; // string |
| }else{ |
| return bs.CONTENT_BOX; // string |
| } |
| }else{ |
| if(arguments.length == 0){ node = document.documentElement; } |
| var sizing; |
| if(!h.ie){ |
| sizing = dojo.html.getStyle(node, "-moz-box-sizing"); |
| if(!sizing){ |
| sizing = dojo.html.getStyle(node, "box-sizing"); |
| } |
| } |
| return (sizing ? sizing : bs.CONTENT_BOX); // string |
| } |
| } |
| |
| dojo.html.isBorderBox = function(/* HTMLElement */node){ |
| // summary |
| // returns whether the passed element is using border box sizing or not. |
| return (dojo.html.getBoxSizing(node) == dojo.html.boxSizing.BORDER_BOX); // boolean |
| } |
| |
| dojo.html.getBorderBox = function(/* HTMLElement */node){ |
| // summary |
| // Returns the dimensions of the passed element based on border-box sizing. |
| node = dojo.byId(node); |
| return { width: node.offsetWidth, height: node.offsetHeight }; // object |
| } |
| |
| dojo.html.getPaddingBox = function(/* HTMLElement */node){ |
| // summary |
| // Returns the dimensions of the padding box (see http://www.w3.org/TR/CSS21/box.html) |
| var box = dojo.html.getBorderBox(node); |
| var border = dojo.html.getBorder(node); |
| return { |
| width: box.width - border.width, |
| height:box.height - border.height |
| }; // object |
| } |
| |
| dojo.html.getContentBox = function(/* HTMLElement */node){ |
| // summary |
| // Returns the dimensions of the content box (see http://www.w3.org/TR/CSS21/box.html) |
| node = dojo.byId(node); |
| var padborder = dojo.html.getPadBorder(node); |
| return { |
| width: node.offsetWidth - padborder.width, |
| height: node.offsetHeight - padborder.height |
| }; // object |
| } |
| |
| dojo.html.setContentBox = function(/* HTMLElement */node, /* object */args){ |
| // summary |
| // Sets the dimensions of the passed node according to content sizing. |
| node = dojo.byId(node); |
| var width = 0; var height = 0; |
| var isbb = dojo.html.isBorderBox(node); |
| var padborder = (isbb ? dojo.html.getPadBorder(node) : { width: 0, height: 0}); |
| var ret = {}; |
| if(typeof args.width != "undefined"){ |
| width = args.width + padborder.width; |
| ret.width = dojo.html.setPositivePixelValue(node, "width", width); |
| } |
| if(typeof args.height != "undefined"){ |
| height = args.height + padborder.height; |
| ret.height = dojo.html.setPositivePixelValue(node, "height", height); |
| } |
| return ret; // object |
| } |
| |
| dojo.html.getMarginBox = function(/* HTMLElement */node){ |
| // summary |
| // returns the dimensions of the passed node including any margins. |
| var borderbox = dojo.html.getBorderBox(node); |
| var margin = dojo.html.getMargin(node); |
| return { width: borderbox.width + margin.width, height: borderbox.height + margin.height }; // object |
| } |
| |
| dojo.html.setMarginBox = function(/* HTMLElement */node, /* object */args){ |
| // summary |
| // Sets the dimensions of the passed node using margin box calcs. |
| node = dojo.byId(node); |
| var width = 0; var height = 0; |
| var isbb = dojo.html.isBorderBox(node); |
| var padborder = (!isbb ? dojo.html.getPadBorder(node) : { width: 0, height: 0 }); |
| var margin = dojo.html.getMargin(node); |
| var ret = {}; |
| if(typeof args.width != "undefined"){ |
| width = args.width - padborder.width; |
| width -= margin.width; |
| ret.width = dojo.html.setPositivePixelValue(node, "width", width); |
| } |
| if(typeof args.height != "undefined"){ |
| height = args.height - padborder.height; |
| height -= margin.height; |
| ret.height = dojo.html.setPositivePixelValue(node, "height", height); |
| } |
| return ret; // object |
| } |
| |
| dojo.html.getElementBox = function(/* HTMLElement */node, /* string */type){ |
| // summary |
| // return dimesions of a node based on the passed box model type. |
| var bs = dojo.html.boxSizing; |
| switch(type){ |
| case bs.MARGIN_BOX: |
| return dojo.html.getMarginBox(node); // object |
| case bs.BORDER_BOX: |
| return dojo.html.getBorderBox(node); // object |
| case bs.PADDING_BOX: |
| return dojo.html.getPaddingBox(node); // object |
| case bs.CONTENT_BOX: |
| default: |
| return dojo.html.getContentBox(node); // object |
| } |
| } |
| // in: coordinate array [x,y,w,h] or dom node |
| // return: coordinate object |
| dojo.html.toCoordinateObject = dojo.html.toCoordinateArray = function(/* array */coords, /* boolean? */includeScroll, /* string? */boxtype) { |
| // summary |
| // Converts an array of coordinates into an object of named arguments. |
| if(coords instanceof Array || typeof coords == "array"){ |
| dojo.deprecated("dojo.html.toCoordinateArray", "use dojo.html.toCoordinateObject({left: , top: , width: , height: }) instead", "0.5"); |
| // coords is already an array (of format [x,y,w,h]), just return it |
| while ( coords.length < 4 ) { coords.push(0); } |
| while ( coords.length > 4 ) { coords.pop(); } |
| var ret = { |
| left: coords[0], |
| top: coords[1], |
| width: coords[2], |
| height: coords[3] |
| }; |
| }else if(!coords.nodeType && !(coords instanceof String || typeof coords == "string") && |
| ('width' in coords || 'height' in coords || 'left' in coords || |
| 'x' in coords || 'top' in coords || 'y' in coords)){ |
| // coords is a coordinate object or at least part of one |
| var ret = { |
| left: coords.left||coords.x||0, |
| top: coords.top||coords.y||0, |
| width: coords.width||0, |
| height: coords.height||0 |
| }; |
| }else{ |
| // coords is an dom object (or dom object id); return it's coordinates |
| var node = dojo.byId(coords); |
| var pos = dojo.html.abs(node, includeScroll, boxtype); |
| var marginbox = dojo.html.getMarginBox(node); |
| var ret = { |
| left: pos.left, |
| top: pos.top, |
| width: marginbox.width, |
| height: marginbox.height |
| }; |
| } |
| ret.x = ret.left; |
| ret.y = ret.top; |
| return ret; // object |
| } |
| |
| dojo.html.setMarginBoxWidth = dojo.html.setOuterWidth = function(node, width){ |
| return dojo.html._callDeprecated("setMarginBoxWidth", "setMarginBox", arguments, "width"); |
| } |
| dojo.html.setMarginBoxHeight = dojo.html.setOuterHeight = function(){ |
| return dojo.html._callDeprecated("setMarginBoxHeight", "setMarginBox", arguments, "height"); |
| } |
| dojo.html.getMarginBoxWidth = dojo.html.getOuterWidth = function(){ |
| return dojo.html._callDeprecated("getMarginBoxWidth", "getMarginBox", arguments, null, "width"); |
| } |
| dojo.html.getMarginBoxHeight = dojo.html.getOuterHeight = function(){ |
| return dojo.html._callDeprecated("getMarginBoxHeight", "getMarginBox", arguments, null, "height"); |
| } |
| dojo.html.getTotalOffset = function(node, type, includeScroll){ |
| return dojo.html._callDeprecated("getTotalOffset", "getAbsolutePosition", arguments, null, type); |
| } |
| dojo.html.getAbsoluteX = function(node, includeScroll){ |
| return dojo.html._callDeprecated("getAbsoluteX", "getAbsolutePosition", arguments, null, "x"); |
| } |
| dojo.html.getAbsoluteY = function(node, includeScroll){ |
| return dojo.html._callDeprecated("getAbsoluteY", "getAbsolutePosition", arguments, null, "y"); |
| } |
| dojo.html.totalOffsetLeft = function(node, includeScroll){ |
| return dojo.html._callDeprecated("totalOffsetLeft", "getAbsolutePosition", arguments, null, "left"); |
| } |
| dojo.html.totalOffsetTop = function(node, includeScroll){ |
| return dojo.html._callDeprecated("totalOffsetTop", "getAbsolutePosition", arguments, null, "top"); |
| } |
| dojo.html.getMarginWidth = function(node){ |
| return dojo.html._callDeprecated("getMarginWidth", "getMargin", arguments, null, "width"); |
| } |
| dojo.html.getMarginHeight = function(node){ |
| return dojo.html._callDeprecated("getMarginHeight", "getMargin", arguments, null, "height"); |
| } |
| dojo.html.getBorderWidth = function(node){ |
| return dojo.html._callDeprecated("getBorderWidth", "getBorder", arguments, null, "width"); |
| } |
| dojo.html.getBorderHeight = function(node){ |
| return dojo.html._callDeprecated("getBorderHeight", "getBorder", arguments, null, "height"); |
| } |
| dojo.html.getPaddingWidth = function(node){ |
| return dojo.html._callDeprecated("getPaddingWidth", "getPadding", arguments, null, "width"); |
| } |
| dojo.html.getPaddingHeight = function(node){ |
| return dojo.html._callDeprecated("getPaddingHeight", "getPadding", arguments, null, "height"); |
| } |
| dojo.html.getPadBorderWidth = function(node){ |
| return dojo.html._callDeprecated("getPadBorderWidth", "getPadBorder", arguments, null, "width"); |
| } |
| dojo.html.getPadBorderHeight = function(node){ |
| return dojo.html._callDeprecated("getPadBorderHeight", "getPadBorder", arguments, null, "height"); |
| } |
| dojo.html.getBorderBoxWidth = dojo.html.getInnerWidth = function(){ |
| return dojo.html._callDeprecated("getBorderBoxWidth", "getBorderBox", arguments, null, "width"); |
| } |
| dojo.html.getBorderBoxHeight = dojo.html.getInnerHeight = function(){ |
| return dojo.html._callDeprecated("getBorderBoxHeight", "getBorderBox", arguments, null, "height"); |
| } |
| dojo.html.getContentBoxWidth = dojo.html.getContentWidth = function(){ |
| return dojo.html._callDeprecated("getContentBoxWidth", "getContentBox", arguments, null, "width"); |
| } |
| dojo.html.getContentBoxHeight = dojo.html.getContentHeight = function(){ |
| return dojo.html._callDeprecated("getContentBoxHeight", "getContentBox", arguments, null, "height"); |
| } |
| dojo.html.setContentBoxWidth = dojo.html.setContentWidth = function(node, width){ |
| return dojo.html._callDeprecated("setContentBoxWidth", "setContentBox", arguments, "width"); |
| } |
| dojo.html.setContentBoxHeight = dojo.html.setContentHeight = function(node, height){ |
| return dojo.html._callDeprecated("setContentBoxHeight", "setContentBox", arguments, "height"); |
| } |
| |
| dojo.provide("dojo.lfx.html"); |
| |
| |
| |
| |
| |
| |
| |
| |
| dojo.lfx.html._byId = function(nodes){ |
| if(!nodes){ return []; } |
| if(dojo.lang.isArrayLike(nodes)){ |
| if(!nodes.alreadyChecked){ |
| var n = []; |
| dojo.lang.forEach(nodes, function(node){ |
| n.push(dojo.byId(node)); |
| }); |
| n.alreadyChecked = true; |
| return n; |
| }else{ |
| return nodes; |
| } |
| }else{ |
| var n = []; |
| n.push(dojo.byId(nodes)); |
| n.alreadyChecked = true; |
| return n; |
| } |
| } |
| |
| dojo.lfx.html.propertyAnimation = function( /*DOMNode[]*/ nodes, |
| /*Object[]*/ propertyMap, |
| /*int*/ duration, |
| /*function*/ easing, |
| /*Object*/ handlers){ |
| // summary: Returns an animation that will transition the properties of "nodes" |
| // depending how they are defined in "propertyMap". |
| // nodes: An array of DOMNodes or one DOMNode. |
| // propertyMap: { property: String, start: Decimal?, end: Decimal?, units: String? } |
| // An array of objects defining properties to change. |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // handlers: { handler: Function?, onstart: Function?, onstop: Function?, onanimate: Function? } |
| nodes = dojo.lfx.html._byId(nodes); |
| |
| var targs = { |
| "propertyMap": propertyMap, |
| "nodes": nodes, |
| "duration": duration, |
| "easing": easing||dojo.lfx.easeDefault |
| }; |
| |
| var setEmUp = function(args){ |
| if(args.nodes.length==1){ |
| // FIXME: we're only supporting start-value filling when one node is |
| // passed |
| |
| var pm = args.propertyMap; |
| if(!dojo.lang.isArray(args.propertyMap)){ |
| // it's stupid to have to pack an array with a set of objects |
| // when you can just pass in an object list |
| var parr = []; |
| for(var pname in pm){ |
| pm[pname].property = pname; |
| parr.push(pm[pname]); |
| } |
| pm = args.propertyMap = parr; |
| } |
| dojo.lang.forEach(pm, function(prop){ |
| if(dj_undef("start", prop)){ |
| if(prop.property != "opacity"){ |
| prop.start = parseInt(dojo.html.getComputedStyle(args.nodes[0], prop.property)); |
| }else{ |
| prop.start = dojo.html.getOpacity(args.nodes[0]); |
| } |
| } |
| }); |
| } |
| } |
| |
| var coordsAsInts = function(coords){ |
| var cints = []; |
| dojo.lang.forEach(coords, function(c){ |
| cints.push(Math.round(c)); |
| }); |
| return cints; |
| } |
| |
| var setStyle = function(n, style){ |
| n = dojo.byId(n); |
| if(!n || !n.style){ return; } |
| for(var s in style){ |
| try{ |
| if(s == "opacity"){ |
| dojo.html.setOpacity(n, style[s]); |
| }else{ |
| n.style[s] = style[s]; |
| } |
| }catch(e){ dojo.debug(e); } |
| } |
| } |
| |
| var propLine = function(properties){ |
| this._properties = properties; |
| this.diffs = new Array(properties.length); |
| dojo.lang.forEach(properties, function(prop, i){ |
| // calculate the end - start to optimize a bit |
| if(dojo.lang.isFunction(prop.start)){ |
| prop.start = prop.start(prop, i); |
| } |
| if(dojo.lang.isFunction(prop.end)){ |
| prop.end = prop.end(prop, i); |
| } |
| if(dojo.lang.isArray(prop.start)){ |
| // don't loop through the arrays |
| this.diffs[i] = null; |
| }else if(prop.start instanceof dojo.gfx.color.Color){ |
| // save these so we don't have to call toRgb() every getValue() call |
| prop.startRgb = prop.start.toRgb(); |
| prop.endRgb = prop.end.toRgb(); |
| }else{ |
| this.diffs[i] = prop.end - prop.start; |
| } |
| }, this); |
| |
| this.getValue = function(n){ |
| var ret = {}; |
| dojo.lang.forEach(this._properties, function(prop, i){ |
| var value = null; |
| if(dojo.lang.isArray(prop.start)){ |
| // FIXME: what to do here? |
| }else if(prop.start instanceof dojo.gfx.color.Color){ |
| value = (prop.units||"rgb") + "("; |
| for(var j = 0 ; j < prop.startRgb.length ; j++){ |
| value += Math.round(((prop.endRgb[j] - prop.startRgb[j]) * n) + prop.startRgb[j]) + (j < prop.startRgb.length - 1 ? "," : ""); |
| } |
| value += ")"; |
| }else{ |
| value = ((this.diffs[i]) * n) + prop.start + (prop.property != "opacity" ? prop.units||"px" : ""); |
| } |
| ret[dojo.html.toCamelCase(prop.property)] = value; |
| }, this); |
| return ret; |
| } |
| } |
| |
| var anim = new dojo.lfx.Animation({ |
| beforeBegin: function(){ |
| setEmUp(targs); |
| anim.curve = new propLine(targs.propertyMap); |
| }, |
| onAnimate: function(propValues){ |
| dojo.lang.forEach(targs.nodes, function(node){ |
| setStyle(node, propValues); |
| }); |
| } |
| }, |
| targs.duration, |
| null, |
| targs.easing |
| ); |
| if(handlers){ |
| for(var x in handlers){ |
| if(dojo.lang.isFunction(handlers[x])){ |
| anim.connect(x, anim, handlers[x]); |
| } |
| } |
| } |
| |
| return anim; // dojo.lfx.Animation |
| } |
| |
| dojo.lfx.html._makeFadeable = function(nodes){ |
| var makeFade = function(node){ |
| if(dojo.render.html.ie){ |
| // only set the zoom if the "tickle" value would be the same as the |
| // default |
| if( (node.style.zoom.length == 0) && |
| (dojo.html.getStyle(node, "zoom") == "normal") ){ |
| // make sure the node "hasLayout" |
| // NOTE: this has been tested with larger and smaller user-set text |
| // sizes and works fine |
| node.style.zoom = "1"; |
| // node.style.zoom = "normal"; |
| } |
| // don't set the width to auto if it didn't already cascade that way. |
| // We don't want to f anyones designs |
| if( (node.style.width.length == 0) && |
| (dojo.html.getStyle(node, "width") == "auto") ){ |
| node.style.width = "auto"; |
| } |
| } |
| } |
| if(dojo.lang.isArrayLike(nodes)){ |
| dojo.lang.forEach(nodes, makeFade); |
| }else{ |
| makeFade(nodes); |
| } |
| } |
| |
| dojo.lfx.html.fade = function(/*DOMNode[]*/ nodes, |
| /*Object*/values, |
| /*int?*/ duration, |
| /*Function?*/ easing, |
| /*Function?*/ callback){ |
| // summary:Returns an animation that will fade the "nodes" from the start to end values passed. |
| // nodes: An array of DOMNodes or one DOMNode. |
| // values: { start: Decimal?, end: Decimal? } |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| nodes = dojo.lfx.html._byId(nodes); |
| var props = { property: "opacity" }; |
| if(!dj_undef("start", values)){ |
| props.start = values.start; |
| }else{ |
| props.start = function(){ return dojo.html.getOpacity(nodes[0]); }; |
| } |
| |
| if(!dj_undef("end", values)){ |
| props.end = values.end; |
| }else{ |
| dojo.raise("dojo.lfx.html.fade needs an end value"); |
| } |
| |
| var anim = dojo.lfx.propertyAnimation(nodes, [ props ], duration, easing); |
| anim.connect("beforeBegin", function(){ |
| dojo.lfx.html._makeFadeable(nodes); |
| }); |
| if(callback){ |
| anim.connect("onEnd", function(){ callback(nodes, anim); }); |
| } |
| |
| return anim; // dojo.lfx.Animation |
| } |
| |
| dojo.lfx.html.fadeIn = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){ |
| // summary: Returns an animation that will fade "nodes" from its current opacity to fully opaque. |
| // nodes: An array of DOMNodes or one DOMNode. |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| return dojo.lfx.html.fade(nodes, { end: 1 }, duration, easing, callback); // dojo.lfx.Animation |
| } |
| |
| dojo.lfx.html.fadeOut = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){ |
| // summary: Returns an animation that will fade "nodes" from its current opacity to fully transparent. |
| // nodes: An array of DOMNodes or one DOMNode. |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| return dojo.lfx.html.fade(nodes, { end: 0 }, duration, easing, callback); // dojo.lfx.Animation |
| } |
| |
| dojo.lfx.html.fadeShow = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){ |
| // summary: Returns an animation that will fade "nodes" from transparent to opaque and shows |
| // "nodes" at the end if it is hidden. |
| // nodes: An array of DOMNodes or one DOMNode. |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| nodes=dojo.lfx.html._byId(nodes); |
| dojo.lang.forEach(nodes, function(node){ |
| dojo.html.setOpacity(node, 0.0); |
| }); |
| |
| var anim = dojo.lfx.html.fadeIn(nodes, duration, easing, callback); |
| anim.connect("beforeBegin", function(){ |
| if(dojo.lang.isArrayLike(nodes)){ |
| dojo.lang.forEach(nodes, dojo.html.show); |
| }else{ |
| dojo.html.show(nodes); |
| } |
| }); |
| |
| return anim; // dojo.lfx.Animation |
| } |
| |
| dojo.lfx.html.fadeHide = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){ |
| // summary: Returns an animation that will fade "nodes" from its current opacity to opaque and hides |
| // "nodes" at the end. |
| // nodes: An array of DOMNodes or one DOMNode. |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| var anim = dojo.lfx.html.fadeOut(nodes, duration, easing, function(){ |
| if(dojo.lang.isArrayLike(nodes)){ |
| dojo.lang.forEach(nodes, dojo.html.hide); |
| }else{ |
| dojo.html.hide(nodes); |
| } |
| if(callback){ callback(nodes, anim); } |
| }); |
| |
| return anim; // dojo.lfx.Animation |
| } |
| |
| dojo.lfx.html.wipeIn = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){ |
| // summary: Returns an animation that will show and wipe in "nodes". |
| // nodes: An array of DOMNodes or one DOMNode. |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| nodes = dojo.lfx.html._byId(nodes); |
| var anims = []; |
| |
| dojo.lang.forEach(nodes, function(node){ |
| var oprop = { }; // old properties of node (before we mucked w/them) |
| |
| // get node height, either it's natural height or it's height specified via style or class attributes |
| // (for FF, the node has to be (temporarily) rendered to measure height) |
| // TODO: should this offscreen code be part of dojo.html, so that getBorderBox() works on hidden nodes? |
| var origTop, origLeft, origPosition; |
| with(node.style){ |
| origTop=top; origLeft=left; origPosition=position; |
| top="-9999px"; left="-9999px"; position="absolute"; |
| display=""; |
| } |
| var nodeHeight = dojo.html.getBorderBox(node).height; |
| with(node.style){ |
| top=origTop; left=origLeft; position=origPosition; |
| display="none"; |
| } |
| |
| var anim = dojo.lfx.propertyAnimation(node, |
| { "height": { |
| start: 1, // 0 causes IE to display the whole panel |
| end: function(){ return nodeHeight; } |
| } |
| }, |
| duration, |
| easing); |
| |
| anim.connect("beforeBegin", function(){ |
| oprop.overflow = node.style.overflow; |
| oprop.height = node.style.height; |
| with(node.style){ |
| overflow = "hidden"; |
| height = "1px"; // 0 causes IE to display the whole panel |
| } |
| dojo.html.show(node); |
| }); |
| |
| anim.connect("onEnd", function(){ |
| with(node.style){ |
| overflow = oprop.overflow; |
| height = oprop.height; |
| } |
| if(callback){ callback(node, anim); } |
| }); |
| anims.push(anim); |
| }); |
| |
| return dojo.lfx.combine(anims); // dojo.lfx.Combine |
| } |
| |
| dojo.lfx.html.wipeOut = function(/*DOMNode[]*/ nodes, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){ |
| // summary: Returns an animation that will wipe out and hide "nodes". |
| // nodes: An array of DOMNodes or one DOMNode. |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| nodes = dojo.lfx.html._byId(nodes); |
| var anims = []; |
| |
| dojo.lang.forEach(nodes, function(node){ |
| var oprop = { }; // old properties of node (before we mucked w/them) |
| var anim = dojo.lfx.propertyAnimation(node, |
| { "height": { |
| start: function(){ return dojo.html.getContentBox(node).height; }, |
| end: 1 // 0 causes IE to display the whole panel |
| } |
| }, |
| duration, |
| easing, |
| { |
| "beforeBegin": function(){ |
| oprop.overflow = node.style.overflow; |
| oprop.height = node.style.height; |
| with(node.style){ |
| overflow = "hidden"; |
| } |
| dojo.html.show(node); |
| }, |
| |
| "onEnd": function(){ |
| dojo.html.hide(node); |
| with(node.style){ |
| overflow = oprop.overflow; |
| height = oprop.height; |
| } |
| if(callback){ callback(node, anim); } |
| } |
| } |
| ); |
| anims.push(anim); |
| }); |
| |
| return dojo.lfx.combine(anims); // dojo.lfx.Combine |
| } |
| |
| dojo.lfx.html.slideTo = function(/*DOMNode*/ nodes, |
| /*Object*/ coords, |
| /*int?*/ duration, |
| /*Function?*/ easing, |
| /*Function?*/ callback){ |
| // summary: Returns an animation that will slide "nodes" from its current position to |
| // the position defined in "coords". |
| // nodes: An array of DOMNodes or one DOMNode. |
| // coords: { top: Decimal?, left: Decimal? } |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| nodes = dojo.lfx.html._byId(nodes); |
| var anims = []; |
| var compute = dojo.html.getComputedStyle; |
| |
| if(dojo.lang.isArray(coords)){ |
| /* coords: Array |
| pId: a */ |
| dojo.deprecated('dojo.lfx.html.slideTo(node, array)', 'use dojo.lfx.html.slideTo(node, {top: value, left: value});', '0.5'); |
| coords = { top: coords[0], left: coords[1] }; |
| } |
| dojo.lang.forEach(nodes, function(node){ |
| var top = null; |
| var left = null; |
| |
| var init = (function(){ |
| var innerNode = node; |
| return function(){ |
| var pos = compute(innerNode, 'position'); |
| top = (pos == 'absolute' ? node.offsetTop : parseInt(compute(node, 'top')) || 0); |
| left = (pos == 'absolute' ? node.offsetLeft : parseInt(compute(node, 'left')) || 0); |
| |
| if (!dojo.lang.inArray(['absolute', 'relative'], pos)) { |
| var ret = dojo.html.abs(innerNode, true); |
| dojo.html.setStyleAttributes(innerNode, "position:absolute;top:"+ret.y+"px;left:"+ret.x+"px;"); |
| top = ret.y; |
| left = ret.x; |
| } |
| } |
| })(); |
| init(); |
| |
| var anim = dojo.lfx.propertyAnimation(node, |
| { "top": { start: top, end: (coords.top||0) }, |
| "left": { start: left, end: (coords.left||0) } |
| }, |
| duration, |
| easing, |
| { "beforeBegin": init } |
| ); |
| |
| if(callback){ |
| anim.connect("onEnd", function(){ callback(nodes, anim); }); |
| } |
| |
| anims.push(anim); |
| }); |
| |
| return dojo.lfx.combine(anims); // dojo.lfx.Combine |
| } |
| |
| dojo.lfx.html.slideBy = function(/*DOMNode*/ nodes, /*Object*/ coords, /*int?*/ duration, /*Function?*/ easing, /*Function?*/ callback){ |
| // summary: Returns an animation that will slide "nodes" from its current position |
| // to its current position plus the numbers defined in "coords". |
| // nodes: An array of DOMNodes or one DOMNode. |
| // coords: { top: Decimal?, left: Decimal? } |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| nodes = dojo.lfx.html._byId(nodes); |
| var anims = []; |
| var compute = dojo.html.getComputedStyle; |
| |
| if(dojo.lang.isArray(coords)){ |
| /* coords: Array |
| pId: a */ |
| dojo.deprecated('dojo.lfx.html.slideBy(node, array)', 'use dojo.lfx.html.slideBy(node, {top: value, left: value});', '0.5'); |
| coords = { top: coords[0], left: coords[1] }; |
| } |
| |
| dojo.lang.forEach(nodes, function(node){ |
| var top = null; |
| var left = null; |
| |
| var init = (function(){ |
| var innerNode = node; |
| return function(){ |
| var pos = compute(innerNode, 'position'); |
| top = (pos == 'absolute' ? node.offsetTop : parseInt(compute(node, 'top')) || 0); |
| left = (pos == 'absolute' ? node.offsetLeft : parseInt(compute(node, 'left')) || 0); |
| |
| if (!dojo.lang.inArray(['absolute', 'relative'], pos)) { |
| var ret = dojo.html.abs(innerNode, true); |
| dojo.html.setStyleAttributes(innerNode, "position:absolute;top:"+ret.y+"px;left:"+ret.x+"px;"); |
| top = ret.y; |
| left = ret.x; |
| } |
| } |
| })(); |
| init(); |
| |
| var anim = dojo.lfx.propertyAnimation(node, |
| { |
| "top": { start: top, end: top+(coords.top||0) }, |
| "left": { start: left, end: left+(coords.left||0) } |
| }, |
| duration, |
| easing).connect("beforeBegin", init); |
| |
| if(callback){ |
| anim.connect("onEnd", function(){ callback(nodes, anim); }); |
| } |
| |
| anims.push(anim); |
| }); |
| |
| return dojo.lfx.combine(anims); // dojo.lfx.Combine |
| } |
| |
| dojo.lfx.html.explode = function(/*DOMNode*/ start, |
| /*DOMNode*/ endNode, |
| /*int?*/ duration, |
| /*Function?*/ easing, |
| /*Function?*/ callback){ |
| // summary: Returns an animation that will |
| // start: |
| // endNode: |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| var h = dojo.html; |
| start = dojo.byId(start); |
| endNode = dojo.byId(endNode); |
| var startCoords = h.toCoordinateObject(start, true); |
| var outline = document.createElement("div"); |
| h.copyStyle(outline, endNode); |
| if(endNode.explodeClassName){ outline.className = endNode.explodeClassName; } |
| with(outline.style){ |
| position = "absolute"; |
| display = "none"; |
| // border = "1px solid black"; |
| var backgroundStyle = h.getStyle(start, "background-color"); |
| backgroundColor = backgroundStyle ? backgroundStyle.toLowerCase() : "transparent"; |
| backgroundColor = (backgroundColor == "transparent") ? "rgb(221, 221, 221)" : backgroundColor; |
| } |
| dojo.body().appendChild(outline); |
| |
| with(endNode.style){ |
| visibility = "hidden"; |
| display = "block"; |
| } |
| var endCoords = h.toCoordinateObject(endNode, true); |
| with(endNode.style){ |
| display = "none"; |
| visibility = "visible"; |
| } |
| |
| var props = { opacity: { start: 0.5, end: 1.0 } }; |
| dojo.lang.forEach(["height", "width", "top", "left"], function(type){ |
| props[type] = { start: startCoords[type], end: endCoords[type] } |
| }); |
| |
| var anim = new dojo.lfx.propertyAnimation(outline, |
| props, |
| duration, |
| easing, |
| { |
| "beforeBegin": function(){ |
| h.setDisplay(outline, "block"); |
| }, |
| "onEnd": function(){ |
| h.setDisplay(endNode, "block"); |
| outline.parentNode.removeChild(outline); |
| } |
| } |
| ); |
| |
| if(callback){ |
| anim.connect("onEnd", function(){ callback(endNode, anim); }); |
| } |
| return anim; // dojo.lfx.Animation |
| } |
| |
| dojo.lfx.html.implode = function(/*DOMNode*/ startNode, |
| /*DOMNode*/ end, |
| /*int?*/ duration, |
| /*Function?*/ easing, |
| /*Function?*/ callback){ |
| // summary: Returns an animation that will |
| // startNode: |
| // end: |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| var h = dojo.html; |
| startNode = dojo.byId(startNode); |
| end = dojo.byId(end); |
| var startCoords = dojo.html.toCoordinateObject(startNode, true); |
| var endCoords = dojo.html.toCoordinateObject(end, true); |
| |
| var outline = document.createElement("div"); |
| dojo.html.copyStyle(outline, startNode); |
| if (startNode.explodeClassName) { outline.className = startNode.explodeClassName; } |
| dojo.html.setOpacity(outline, 0.3); |
| with(outline.style){ |
| position = "absolute"; |
| display = "none"; |
| backgroundColor = h.getStyle(startNode, "background-color").toLowerCase(); |
| } |
| dojo.body().appendChild(outline); |
| |
| var props = { opacity: { start: 1.0, end: 0.5 } }; |
| dojo.lang.forEach(["height", "width", "top", "left"], function(type){ |
| props[type] = { start: startCoords[type], end: endCoords[type] } |
| }); |
| |
| var anim = new dojo.lfx.propertyAnimation(outline, |
| props, |
| duration, |
| easing, |
| { |
| "beforeBegin": function(){ |
| dojo.html.hide(startNode); |
| dojo.html.show(outline); |
| }, |
| "onEnd": function(){ |
| outline.parentNode.removeChild(outline); |
| } |
| } |
| ); |
| |
| if(callback){ |
| anim.connect("onEnd", function(){ callback(startNode, anim); }); |
| } |
| return anim; // dojo.lfx.Animation |
| } |
| |
| dojo.lfx.html.highlight = function(/*DOMNode[]*/ nodes, |
| /*dojo.gfx.color.Color*/ startColor, |
| /*int?*/ duration, |
| /*Function?*/ easing, |
| /*Function?*/ callback){ |
| // summary: Returns an animation that will set the background color |
| // of "nodes" to startColor and transition it to "nodes" |
| // original color. |
| // startColor: Color to transition from. |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| nodes = dojo.lfx.html._byId(nodes); |
| var anims = []; |
| |
| dojo.lang.forEach(nodes, function(node){ |
| var color = dojo.html.getBackgroundColor(node); |
| var bg = dojo.html.getStyle(node, "background-color").toLowerCase(); |
| var bgImage = dojo.html.getStyle(node, "background-image"); |
| var wasTransparent = (bg == "transparent" || bg == "rgba(0, 0, 0, 0)"); |
| while(color.length > 3) { color.pop(); } |
| |
| var rgb = new dojo.gfx.color.Color(startColor); |
| var endRgb = new dojo.gfx.color.Color(color); |
| |
| var anim = dojo.lfx.propertyAnimation(node, |
| { "background-color": { start: rgb, end: endRgb } }, |
| duration, |
| easing, |
| { |
| "beforeBegin": function(){ |
| if(bgImage){ |
| node.style.backgroundImage = "none"; |
| } |
| node.style.backgroundColor = "rgb(" + rgb.toRgb().join(",") + ")"; |
| }, |
| "onEnd": function(){ |
| if(bgImage){ |
| node.style.backgroundImage = bgImage; |
| } |
| if(wasTransparent){ |
| node.style.backgroundColor = "transparent"; |
| } |
| if(callback){ |
| callback(node, anim); |
| } |
| } |
| } |
| ); |
| |
| anims.push(anim); |
| }); |
| return dojo.lfx.combine(anims); // dojo.lfx.Combine |
| } |
| |
| dojo.lfx.html.unhighlight = function(/*DOMNode[]*/ nodes, |
| /*dojo.gfx.color.Color*/ endColor, |
| /*int?*/ duration, |
| /*Function?*/ easing, |
| /*Function?*/ callback){ |
| // summary: Returns an animation that will transition "nodes" background color |
| // from its current color to "endColor". |
| // endColor: Color to transition to. |
| // duration: Duration of the animation in milliseconds. |
| // easing: An easing function. |
| // callback: Function to run at the end of the animation. |
| nodes = dojo.lfx.html._byId(nodes); |
| var anims = []; |
| |
| dojo.lang.forEach(nodes, function(node){ |
| var color = new dojo.gfx.color.Color(dojo.html.getBackgroundColor(node)); |
| var rgb = new dojo.gfx.color.Color(endColor); |
| |
| var bgImage = dojo.html.getStyle(node, "background-image"); |
| |
| var anim = dojo.lfx.propertyAnimation(node, |
| { "background-color": { start: color, end: rgb } }, |
| duration, |
| easing, |
| { |
| "beforeBegin": function(){ |
| if(bgImage){ |
| node.style.backgroundImage = "none"; |
| } |
| node.style.backgroundColor = "rgb(" + color.toRgb().join(",") + ")"; |
| }, |
| "onEnd": function(){ |
| if(callback){ |
| callback(node, anim); |
| } |
| } |
| } |
| ); |
| anims.push(anim); |
| }); |
| return dojo.lfx.combine(anims); // dojo.lfx.Combine |
| } |
| |
| dojo.lang.mixin(dojo.lfx, dojo.lfx.html); |
| |
| dojo.kwCompoundRequire({ |
| browser: ["dojo.lfx.html"], |
| dashboard: ["dojo.lfx.html"] |
| }); |
| dojo.provide("dojo.lfx.*"); |
| |