/* 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: "sx", revision: Number("$Rev: 8617 $".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 =["ROOT","es-es","es","it-it","pt-br","de","fr-fr","zh-cn","pt","en-us","zh","fr","zh-tw","it","en-gb","xx","de-de","ko-kr","ja-jp","ko","en","ja"]; // 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.xml.Parse"); //TODO: determine dependencies // currently has dependency on dojo.xml.DomUtil nodeTypes constants... // using documentFragment nomenclature to generalize in case we don't want to require passing a collection of nodes with a single parent dojo.xml.Parse = function(){ // summary: // generic class for taking a DOM node and parsing it into an object // based on the "dojo tag name" of that node. // // supported dojoTagName's: // <prefix:tag> => prefix:tag // <dojo:tag> => dojo:tag // <dojoTag> => dojo:tag // <tag dojoType="type"> => dojo:type // <tag dojoType="prefix:type"> => prefix:type // <tag dojo:type="type"> => dojo:type // <tag class="classa dojo-type classb"> => dojo:type var isIE = ((dojo.render.html.capable)&&(dojo.render.html.ie)); // get normalized (lowercase) tagName // some browsers report tagNames in lowercase no matter what function getTagName(node){ /* return ((node)&&(node["tagName"]) ? node.tagName.toLowerCase() : ''); */ try{ return node.tagName.toLowerCase(); }catch(e){ return ""; } } // locate dojo qualified tag name function getDojoTagName(node){ var tagName = getTagName(node); if (!tagName){ return ''; } // any registered tag if((dojo.widget)&&(dojo.widget.tags[tagName])){ return tagName; } // <prefix:tag> => prefix:tag var p = tagName.indexOf(":"); if(p>=0){ return tagName; } // <dojo:tag> => dojo:tag if(tagName.substr(0,5) == "dojo:"){ return tagName; } if(dojo.render.html.capable && dojo.render.html.ie && node.scopeName != 'HTML'){ return node.scopeName.toLowerCase() + ':' + tagName; } // <dojoTag> => dojo:tag if(tagName.substr(0,4) == "dojo"){ // FIXME: this assumes tag names are always lower case return "dojo:" + tagName.substring(4); } // <tag dojoType="prefix:type"> => prefix:type // <tag dojoType="type"> => dojo:type var djt = node.getAttribute("dojoType") || node.getAttribute("dojotype"); if(djt){ if (djt.indexOf(":")<0){ djt = "dojo:"+djt; } return djt.toLowerCase(); } // <tag dojo:type="type"> => dojo:type djt = node.getAttributeNS && node.getAttributeNS(dojo.dom.dojoml,"type"); if(djt){ return "dojo:" + djt.toLowerCase(); } // <tag dojo:type="type"> => dojo:type try{ // FIXME: IE really really doesn't like this, so we squelch errors for it djt = node.getAttribute("dojo:type"); }catch(e){ // FIXME: log? } if(djt){ return "dojo:"+djt.toLowerCase(); } // <tag class="classa dojo-type classb"> => dojo:type if((dj_global["djConfig"])&&(!djConfig["ignoreClassNames"])){ // FIXME: should we make this optionally enabled via djConfig? var classes = node.className||node.getAttribute("class"); // FIXME: following line, without check for existence of classes.indexOf // breaks firefox 1.5's svg widgets if((classes )&&(classes.indexOf)&&(classes.indexOf("dojo-")!=-1)){ var aclasses = classes.split(" "); for(var x=0, c=aclasses.length; x<c; x++){ if(aclasses[x].slice(0, 5) == "dojo-"){ return "dojo:"+aclasses[x].substr(5).toLowerCase(); } } } } // no dojo-qualified name return ''; } this.parseElement = function( /*DomNode*/node, /*Boolean*/hasParentNodeSet, /*Boolean*/optimizeForDojoML, /*Integer*/thisIdx ){ // summary: // recursively parse the passed node, returning a normalized data // structure that represents the "attributes of interest" of said // elements. If optimizeForDojoML is true, only nodes that contain // a "dojo tag name" will be inspected for attributes. // node: the DomNode to be treated as the root of inspection // hasParentNodeSet: no-op, please pass "null" // optimizeForDojoML: should we ignore non-Dojo nodes? Defaults to false. // thisIdx: // a way to specify a synthetic "index" property in the resulting // data structure. Otherwise the index property of the top-level // return element is always "0". // TODOC: document return structure of a non-trivial element set // run shortcuts to bail out of processing up front to save time and // object alloc if possible. var tagName = getTagName(node); //There's a weird bug in IE where it counts end tags, e.g. </dojo:button> as nodes that should be parsed. Ignore these if(isIE && tagName.indexOf("/")==0){ return null; } try{ var attr = node.getAttribute("parseWidgets"); if(attr && attr.toLowerCase() == "false"){ return {}; } }catch(e){/*continue*/} // look for a dojoml qualified name // process dojoml only when optimizeForDojoML is true var process = true; if(optimizeForDojoML){ var dojoTagName = getDojoTagName(node); tagName = dojoTagName || tagName; process = Boolean(dojoTagName); } var parsedNodeSet = {}; parsedNodeSet[tagName] = []; var pos = tagName.indexOf(":"); if(pos>0){ var ns = tagName.substring(0,pos); parsedNodeSet["ns"] = ns; // honor user namespace filters if((dojo.ns)&&(!dojo.ns.allow(ns))){process=false;} } if(process){ var attributeSet = this.parseAttributes(node); for(var attr in attributeSet){ if((!parsedNodeSet[tagName][attr])||(typeof parsedNodeSet[tagName][attr] != "array")){ parsedNodeSet[tagName][attr] = []; } parsedNodeSet[tagName][attr].push(attributeSet[attr]); } // FIXME: we might want to make this optional or provide cloning instead of // referencing, but for now, we include a node reference to allow // instantiated components to figure out their "roots" parsedNodeSet[tagName].nodeRef = node; parsedNodeSet.tagName = tagName; parsedNodeSet.index = thisIdx||0; } var count = 0; for(var i = 0; i < node.childNodes.length; i++){ var tcn = node.childNodes.item(i); switch(tcn.nodeType){ case dojo.dom.ELEMENT_NODE: // element nodes, call this function recursively var ctn = getDojoTagName(tcn) || getTagName(tcn); if(!parsedNodeSet[ctn]){ parsedNodeSet[ctn] = []; } parsedNodeSet[ctn].push(this.parseElement(tcn, true, optimizeForDojoML, count)); if( (tcn.childNodes.length == 1)&& (tcn.childNodes.item(0).nodeType == dojo.dom.TEXT_NODE)){ parsedNodeSet[ctn][parsedNodeSet[ctn].length-1].value = tcn.childNodes.item(0).nodeValue; } count++; break; case dojo.dom.TEXT_NODE: // if a single text node is the child, treat it as an attribute if(node.childNodes.length == 1){ parsedNodeSet[tagName].push({ value: node.childNodes.item(0).nodeValue }); } break; default: break; /* case dojo.dom.ATTRIBUTE_NODE: // attribute node... not meaningful here break; case dojo.dom.CDATA_SECTION_NODE: // cdata section... not sure if this would ever be meaningful... might be... break; case dojo.dom.ENTITY_REFERENCE_NODE: // entity reference node... not meaningful here break; case dojo.dom.ENTITY_NODE: // entity node... not sure if this would ever be meaningful break; case dojo.dom.PROCESSING_INSTRUCTION_NODE: // processing instruction node... not meaningful here break; case dojo.dom.COMMENT_NODE: // comment node... not not sure if this would ever be meaningful break; case dojo.dom.DOCUMENT_NODE: // document node... not sure if this would ever be meaningful break; case dojo.dom.DOCUMENT_TYPE_NODE: // document type node... not meaningful here break; case dojo.dom.DOCUMENT_FRAGMENT_NODE: // document fragment node... not meaningful here break; case dojo.dom.NOTATION_NODE:// notation node... not meaningful here break; */ } } //return (hasParentNodeSet) ? parsedNodeSet[node.tagName] : parsedNodeSet; //if(parsedNodeSet.tagName)dojo.debug("parseElement: RETURNING NODE WITH TAGNAME "+parsedNodeSet.tagName); return parsedNodeSet; }; /* parses a set of attributes on a node into an object tree */ this.parseAttributes = function(/*DomNode*/node){ // summary: // creates an attribute object that maps attribute values for the // passed node. Note that this is similar to creating a JSON // representation of a DOM node. // usage: // a node with the following serialization: // <div foo="bar" baz="thud">...</div> // would yeild the following return structure when passed into this // function: // { // "foo": { // "value": "bar" // }, // "baz": { // "value": "thud" // } // } // var parsedAttributeSet = {}; var atts = node.attributes; // TODO: should we allow for duplicate attributes at this point... // would any of the relevant dom implementations even allow this? var attnode, i=0; while((attnode=atts[i++])){ if(isIE){ if(!attnode){ continue; } if((typeof attnode == "object")&& (typeof attnode.nodeValue == 'undefined')|| (attnode.nodeValue == null)|| (attnode.nodeValue == '')){ continue; } } var nn = attnode.nodeName.split(":"); nn = (nn.length == 2) ? nn[1] : attnode.nodeName; parsedAttributeSet[nn] = { value: attnode.nodeValue }; } return parsedAttributeSet; }; }; dojo.provide("dojo.lang.declare"); dojo.lang.declare = function( /*String*/ className, /*Function|Array*/ superclass, /*Function?*/ init, /*Object|Array*/ props){ /* * summary: Create a feature-rich constructor with a compact notation * className: the name of the constructor (loosely, a "class") * superclass: * may be a Function, or an Array of Functions. If "superclass" is an * array, the first element is used as the prototypical ancestor and * any following Functions become mixin ancestors. * init: an initializer function * props: * an object (or array of objects) whose properties are copied to the * created prototype * description: * Create a constructor using a compact notation for inheritance and * prototype extension. "superclass" argument may be a Function, or an * array of Functions. * * If "superclass" is an array, the first element is used as the * prototypical ancestor and any following Functions become mixin * ancestors. * * All "superclass(es)" must be Functions (not mere Objects). * * Using mixin ancestors provides a type of multiple inheritance. * Mixin ancestors prototypical properties are copied to the subclass, * and any inializater/constructor is invoked. * * Properties of object "props" are copied to the constructor * prototype. If "props" is an array, properties of each object in the * array are copied to the constructor prototype. * * name of the class ("className" argument) is stored in * "declaredClass" property * * Initializer functions are called when an object is instantiated * from this constructor. * * Aliased as "dojo.declare" * * Usage: * * dojo.declare("my.classes.bar", my.classes.foo, * function(){ * // initialization function * this.myComplicatedObject = new ReallyComplicatedObject(); * }, * { // properties to be added to the class prototype * someValue: 2, * someMethod: function(){ * doStuff(); * } * } * ); * */ if((dojo.lang.isFunction(props))||((!props)&&(!dojo.lang.isFunction(init)))){ // parameter juggling to support omitting init param (also allows // reordering init and props arguments) var temp = props; props = init; init = temp; } var mixins = [ ]; if(dojo.lang.isArray(superclass)){ mixins = superclass; superclass = mixins.shift(); } if(!init){ init = dojo.evalObjPath(className, false); if((init)&&(!dojo.lang.isFunction(init))){ init = null }; } var ctor = dojo.lang.declare._makeConstructor(); var scp = (superclass ? superclass.prototype : null); if(scp){ scp.prototyping = true; ctor.prototype = new superclass(); scp.prototyping = false; } ctor.superclass = scp; ctor.mixins = mixins; for(var i=0,l=mixins.length; i<l; i++){ dojo.lang.extend(ctor, mixins[i].prototype); } ctor.prototype.initializer = null; ctor.prototype.declaredClass = className; if(dojo.lang.isArray(props)){ dojo.lang.extend.apply(dojo.lang, [ctor].concat(props)); }else{ dojo.lang.extend(ctor, (props)||{}); } dojo.lang.extend(ctor, dojo.lang.declare._common); ctor.prototype.constructor = ctor; ctor.prototype.initializer = (ctor.prototype.initializer)||(init)||(function(){}); var created = dojo.parseObjPath(className, null, true); created.obj[created.prop] = ctor; return ctor; // Function } dojo.lang.declare._makeConstructor = function(){ return function(){ // get the generational context (which object [or prototype] should be constructed) var self = this._getPropContext(); var s = self.constructor.superclass; if((s)&&(s.constructor)){ if(s.constructor==arguments.callee){ // if this constructor is invoked directly (my.ancestor.call(this)) this._inherited("constructor", arguments); }else{ this._contextMethod(s, "constructor", arguments); } } var ms = (self.constructor.mixins)||([]); for(var i=0, m; (m=ms[i]); i++) { (((m.prototype)&&(m.prototype.initializer))||(m)).apply(this, arguments); } if((!this.prototyping)&&(self.initializer)){ self.initializer.apply(this, arguments); } } } dojo.lang.declare._common = { _getPropContext: function(){ return (this.___proto||this); }, // caches ptype context and calls method on it _contextMethod: function(ptype, method, args){ var result, stack = this.___proto; this.___proto = ptype; try { result = ptype[method].apply(this,(args||[])); } catch(e) { throw e; } finally { this.___proto = stack; } return result; }, _inherited: function(prop, args){ // summary: // Searches backward thru prototype chain to find nearest // ancestral instance of prop. Internal use only. var p = this._getPropContext(); do{ if((!p.constructor)||(!p.constructor.superclass)){ return; } p = p.constructor.superclass; }while(!(prop in p)); return (dojo.lang.isFunction(p[prop]) ? this._contextMethod(p, prop, args) : p[prop]); }, inherited: function(prop, args){ dojo.deprecated("'inherited' method is dangerous, do not up-call! 'inherited' is slated for removal in 0.5; name your super class (or use superclass property) instead.", "0.5"); this._inherited(prop, args); } } dojo.declare = dojo.lang.declare; dojo.provide("dojo.ns"); dojo.ns = { // summary: private object that implements widget namespace management namespaces: {}, failed: {}, loading: {}, loaded: {}, register: function(/*String*/name, /*String*/module, /*Function?*/resolver, /*Boolean?*/noOverride){ // summary: creates and registers a dojo.ns.Ns object if(!noOverride || !this.namespaces[name]){ this.namespaces[name] = new dojo.ns.Ns(name, module, resolver); } }, allow: function(/*String*/name){ // summary: Returns false if 'name' is filtered by configuration or has failed to load, true otherwise if(this.failed[name]){return false;} // Boolean if((djConfig.excludeNamespace)&&(dojo.lang.inArray(djConfig.excludeNamespace, name))){return false;} // Boolean // If the namespace is "dojo", or the user has not specified allowed namespaces return true. // Otherwise, if the user has specifically allowed this namespace, return true, otherwise false. return((name==this.dojo)||(!djConfig.includeNamespace)||(dojo.lang.inArray(djConfig.includeNamespace, name))); // Boolean }, get: function(/*String*/name){ // summary // Return Ns object registered to 'name', if any return this.namespaces[name]; // Ns }, require: function(/*String*/name){ // summary // Try to ensure that 'name' is registered, loading a namespace manifest if necessary var ns = this.namespaces[name]; if((ns)&&(this.loaded[name])){return ns;} // Ns if(!this.allow(name)){return false;} // Boolean if(this.loading[name]){ // FIXME: do we really ever have re-entrancy situation? this would appear to be really bad // original code did not throw an exception, although that seems the only course // adding debug output here to track if this occurs. dojo.debug('dojo.namespace.require: re-entrant request to load namespace "' + name + '" must fail.'); return false; // Boolean } // workaround so we don't break the build system var req = dojo.require; this.loading[name] = true; try { //dojo namespace file is always in the Dojo namespaces folder, not any custom folder if(name=="dojo"){ req("dojo.namespaces.dojo"); }else{ // if no registered module prefix, use ../<name> by convention if(!dojo.hostenv.moduleHasPrefix(name)){ dojo.registerModulePath(name, "../" + name); } req([name, 'manifest'].join('.'), false, true); } if(!this.namespaces[name]){ this.failed[name] = true; //only look for a namespace once } }finally{ this.loading[name]=false; } return this.namespaces[name]; // Ns } } dojo.ns.Ns = function(/*String*/name, /*String*/module, /*Function?*/resolver){ // summary: this object simply encapsulates namespace data this.name = name; this.module = module; this.resolver = resolver; this._loaded = [ ]; this._failed = [ ]; } dojo.ns.Ns.prototype.resolve = function(/*String*/name, /*String*/domain, /*Boolean?*/omitModuleCheck){ //summary: map component with 'name' and 'domain' to a module via namespace resolver, if specified if(!this.resolver || djConfig["skipAutoRequire"]){return false;} // Boolean var fullName = this.resolver(name, domain); //only load a widget once. This is a quicker check than dojo.require does if((fullName)&&(!this._loaded[fullName])&&(!this._failed[fullName])){ //workaround so we don't break the build system var req = dojo.require; req(fullName, false, true); //omit the module check, we'll do it ourselves. if(dojo.hostenv.findModule(fullName, false)){ this._loaded[fullName] = true; }else{ if(!omitModuleCheck){dojo.raise("dojo.ns.Ns.resolve: module '" + fullName + "' not found after loading via namespace '" + this.name + "'");} this._failed[fullName] = true; } } return Boolean(this._loaded[fullName]); // Boolean } dojo.registerNamespace = function(/*String*/name, /*String*/module, /*Function?*/resolver){ // summary: maps a module name to a namespace for widgets, and optionally maps widget names to modules for auto-loading // description: An unregistered namespace is mapped to an eponymous module. // For example, namespace acme is mapped to module acme, and widgets are // assumed to belong to acme.widget. If you want to use a different widget // module, use dojo.registerNamespace. dojo.ns.register.apply(dojo.ns, arguments); } dojo.registerNamespaceResolver = function(/*String*/name, /*Function*/resolver){ // summary: a resolver function maps widget names to modules, so the // widget manager can auto-load needed widget implementations // // description: The resolver provides information to allow Dojo // to load widget modules on demand. When a widget is created, // a namespace resolver can tell Dojo what module to require // to ensure that the widget implementation code is loaded. // // name: will always be lower-case. // // example: // dojo.registerNamespaceResolver("acme", // function(name){ // return "acme.widget."+dojo.string.capitalize(name); // } // ); var n = dojo.ns.namespaces[name]; if(n){ n.resolver = resolver; } } dojo.registerNamespaceManifest = function(/*String*/module, /*String*/path, /*String*/name, /*String*/widgetModule, /*Function?*/resolver){ // summary: convenience function to register a module path, a namespace, and optionally a resolver all at once. dojo.registerModulePath(name, path); dojo.registerNamespace(name, widgetModule, resolver); } // NOTE: rather put this in dojo.widget.Widget, but that fubars debugAtAllCosts dojo.registerNamespace("dojo", "dojo.widget"); dojo.provide("dojo.widget.Manager"); // summary // Manager class for the widgets. // This is an internal class used by dojo; users shouldn't call this class directly. dojo.widget.manager = new function(){ this.widgets = []; this.widgetIds = []; // map of widgetId-->widget for widgets without parents (top level widgets) this.topWidgets = {}; var widgetTypeCtr = {}; var renderPrefixCache = []; this.getUniqueId = function (widgetType) { var widgetId; do{ widgetId = widgetType + "_" + (widgetTypeCtr[widgetType] != undefined ? ++widgetTypeCtr[widgetType] : widgetTypeCtr[widgetType] = 0); }while(this.getWidgetById(widgetId)); return widgetId; } this.add = function(widget){ //dojo.profile.start("dojo.widget.manager.add"); this.widgets.push(widget); // Opera9 uses ID (caps) if(!widget.extraArgs["id"]){ widget.extraArgs["id"] = widget.extraArgs["ID"]; } // FIXME: the rest of this method is very slow! if(widget.widgetId == ""){ if(widget["id"]){ widget.widgetId = widget["id"]; }else if(widget.extraArgs["id"]){ widget.widgetId = widget.extraArgs["id"]; }else{ widget.widgetId = this.getUniqueId(widget.ns+'_'+widget.widgetType); } } if(this.widgetIds[widget.widgetId]){ dojo.debug("widget ID collision on ID: "+widget.widgetId); } this.widgetIds[widget.widgetId] = widget; // Widget.destroy already calls removeById(), so we don't need to // connect() it here //dojo.profile.end("dojo.widget.manager.add"); } this.destroyAll = function(){ for(var x=this.widgets.length-1; x>=0; x--){ try{ // this.widgets[x].destroyChildren(); this.widgets[x].destroy(true); delete this.widgets[x]; }catch(e){ } } } // FIXME: we should never allow removal of the root widget until all others // are removed! this.remove = function(widgetIndex){ if(dojo.lang.isNumber(widgetIndex)){ var tw = this.widgets[widgetIndex].widgetId; delete this.topWidgets[tw]; delete this.widgetIds[tw]; this.widgets.splice(widgetIndex, 1); }else{ this.removeById(widgetIndex); } } // FIXME: suboptimal performance this.removeById = function(id) { if(!dojo.lang.isString(id)){ id = id["widgetId"]; if(!id){ dojo.debug("invalid widget or id passed to removeById"); return; } } for (var i=0; i<this.widgets.length; i++){ if(this.widgets[i].widgetId == id){ this.remove(i); break; } } } this.getWidgetById = function(id){ if(dojo.lang.isString(id)){ return this.widgetIds[id]; } return id; } this.getWidgetsByType = function(type){ var lt = type.toLowerCase(); var getType = (type.indexOf(":") < 0 ? function(x) { return x.widgetType.toLowerCase(); } : function(x) { return x.getNamespacedType(); } ); var ret = []; dojo.lang.forEach(this.widgets, function(x){ if(getType(x) == lt){ret.push(x);} }); return ret; } this.getWidgetsByFilter = function(unaryFunc, onlyOne){ var ret = []; dojo.lang.every(this.widgets, function(x){ if(unaryFunc(x)){ ret.push(x); if(onlyOne){return false;} } return true; }); return (onlyOne ? ret[0] : ret); } this.getAllWidgets = function() { return this.widgets.concat(); } // added, trt 2006-01-20 this.getWidgetByNode = function(/* DOMNode */ node){ var w=this.getAllWidgets(); node = dojo.byId(node); for(var i=0; i<w.length; i++){ if(w[i].domNode==node){ return w[i]; } } return null; } // shortcuts, baby this.byId = this.getWidgetById; this.byType = this.getWidgetsByType; this.byFilter = this.getWidgetsByFilter; this.byNode = this.getWidgetByNode; // map of previousally discovered implementation names to constructors var knownWidgetImplementations = {}; // support manually registered widget packages var widgetPackages = ["dojo.widget"]; for (var i=0; i<widgetPackages.length; i++) { // convenience for checking if a package exists (reverse lookup) widgetPackages[widgetPackages[i]] = true; } this.registerWidgetPackage = function(pname) { if(!widgetPackages[pname]){ widgetPackages[pname] = true; widgetPackages.push(pname); } } this.getWidgetPackageList = function() { return dojo.lang.map(widgetPackages, function(elt) { return(elt!==true ? elt : undefined); }); } this.getImplementation = function(widgetName, ctorObject, mixins, ns){ // try and find a name for the widget var impl = this.getImplementationName(widgetName, ns); if(impl){ // var tic = new Date(); var ret = ctorObject ? new impl(ctorObject) : new impl(); // dojo.debug(new Date() - tic); return ret; } } function buildPrefixCache() { for(var renderer in dojo.render){ if(dojo.render[renderer]["capable"] === true){ var prefixes = dojo.render[renderer].prefixes; for(var i=0; i<prefixes.length; i++){ renderPrefixCache.push(prefixes[i].toLowerCase()); } } } // make sure we don't HAVE to prefix widget implementation names // with anything to get them to render //renderPrefixCache.push(""); // empty prefix is included automatically } var findImplementationInModule = function(lowerCaseWidgetName, module){ if(!module){return null;} for(var i=0, l=renderPrefixCache.length, widgetModule; i<=l; i++){ widgetModule = (i<l ? module[renderPrefixCache[i]] : module); if(!widgetModule){continue;} for(var name in widgetModule){ if(name.toLowerCase() == lowerCaseWidgetName){ return widgetModule[name]; } } } return null; } var findImplementation = function(lowerCaseWidgetName, moduleName){ // locate registered widget module var module = dojo.evalObjPath(moduleName, false); // locate a widget implementation in the registered module for our current rendering environment return (module ? findImplementationInModule(lowerCaseWidgetName, module) : null); } this.getImplementationName = function(widgetName, ns){ /* * Locate an implementation (constructor) for 'widgetName' in namespace 'ns' * widgetNames are case INSENSITIVE * * 1. Return value from implementation cache, if available, for quick turnaround. * 2. Locate a namespace registration for 'ns' * 3. If no namespace found, register the conventional one (ns.widget) * 4. Allow the namespace resolver (if any) to load a module for this widget. * 5. Permute the widget name and capable rendering prefixes to locate, cache, and return * an appropriate widget implementation. * 6. If no implementation is found, attempt to load the namespace manifest, * and then look again for an implementation to cache and return. * 7. Use the deprecated widgetPackages registration system to attempt to locate the widget * 8. Fail */ var lowerCaseWidgetName = widgetName.toLowerCase(); // default to dojo namespace ns=ns||"dojo"; // use cache if available var imps = knownWidgetImplementations[ns] || (knownWidgetImplementations[ns]={}); //if(!knownWidgetImplementations[ns]){knownWidgetImplementations[ns]={};} var impl = imps[lowerCaseWidgetName]; if(impl){ return impl; } // (one time) store a list of the render prefixes we are capable of rendering if(!renderPrefixCache.length){ buildPrefixCache(); } // lookup namespace var nsObj = dojo.ns.get(ns); if(!nsObj){ // default to <ns>.widget by convention dojo.ns.register(ns, ns + '.widget'); nsObj = dojo.ns.get(ns); } // allow the namespace to resolve the widget module if(nsObj){nsObj.resolve(widgetName);} // locate a widget implementation in the registered module for our current rendering environment impl = findImplementation(lowerCaseWidgetName, nsObj.module); if(impl){return(imps[lowerCaseWidgetName] = impl)}; // try to load a manifest to resolve this implemenation nsObj = dojo.ns.require(ns); if((nsObj)&&(nsObj.resolver)){ nsObj.resolve(widgetName); impl = findImplementation(lowerCaseWidgetName, nsObj.module); if(impl){return(imps[lowerCaseWidgetName] = impl)}; } // this is an error condition under new rules dojo.deprecated('dojo.widget.Manager.getImplementationName', 'Could not locate widget implementation for "' + widgetName + '" in "' + nsObj.module + '" registered to namespace "' + nsObj.name + '". ' + "Developers must specify correct namespaces for all non-Dojo widgets", "0.5"); // backward compat: if the user has not specified any namespace and their widget is not in dojo.widget.* // search registered widget packages [sic] // note: registerWidgetPackage itself is now deprecated for(var i=0; i<widgetPackages.length; i++){ impl = findImplementation(lowerCaseWidgetName, widgetPackages[i]); if(impl){return(imps[lowerCaseWidgetName] = impl)}; } throw new Error('Could not locate widget implementation for "' + widgetName + '" in "' + nsObj.module + '" registered to namespace "' + nsObj.name + '"'); } // FIXME: does it even belong in this module? // NOTE: this method is implemented by DomWidget.js since not all // hostenv's would have an implementation. /*this.getWidgetFromPrimitive = function(baseRenderType){ dojo.unimplemented("dojo.widget.manager.getWidgetFromPrimitive"); } this.getWidgetFromEvent = function(nativeEvt){ dojo.unimplemented("dojo.widget.manager.getWidgetFromEvent"); }*/ // Catch window resize events and notify top level widgets this.resizing=false; this.onWindowResized = function(){ if(this.resizing){ return; // duplicate event } try{ this.resizing=true; for(var id in this.topWidgets){ var child = this.topWidgets[id]; if(child.checkSize ){ child.checkSize(); } } }catch(e){ }finally{ this.resizing=false; } } if(typeof window != "undefined") { dojo.addOnLoad(this, 'onWindowResized'); // initial sizing dojo.event.connect(window, 'onresize', this, 'onWindowResized'); // window resize } // FIXME: what else? }; (function(){ var dw = dojo.widget; var dwm = dw.manager; var h = dojo.lang.curry(dojo.lang, "hitch", dwm); var g = function(oldName, newName){ dw[(newName||oldName)] = h(oldName); } // copy the methods from the default manager (this) to the widget namespace g("add", "addWidget"); g("destroyAll", "destroyAllWidgets"); g("remove", "removeWidget"); g("removeById", "removeWidgetById"); g("getWidgetById"); g("getWidgetById", "byId"); g("getWidgetsByType"); g("getWidgetsByFilter"); g("getWidgetsByType", "byType"); g("getWidgetsByFilter", "byFilter"); g("getWidgetByNode", "byNode"); dw.all = function(n){ var widgets = dwm.getAllWidgets.apply(dwm, arguments); if(arguments.length > 0) { return widgets[n]; } return widgets; } g("registerWidgetPackage"); g("getImplementation", "getWidgetImplementation"); g("getImplementationName", "getWidgetImplementationName"); dw.widgets = dwm.widgets; dw.widgetIds = dwm.widgetIds; dw.root = dwm.root; })(); 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.kwCompoundRequire({ common: [["dojo.uri.Uri", false, false]] }); dojo.provide("dojo.uri.*"); 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.a11y"); dojo.a11y = { // imgPath: String path to the test image for determining if images are displayed or not // doAccessibleCheck: Boolean if true will perform check for need to create accessible widgets // accessible: Boolean uninitialized when null (accessible check has not been performed) // if true generate accessible widgets imgPath:dojo.uri.moduleUri("dojo.widget", "templates/images"), doAccessibleCheck: true, accessible: null, checkAccessible: function(){ // summary: // perform check for accessibility if accessibility checking is turned // on and the accessibility test has not been performed yet if(this.accessible === null){ this.accessible = false; //default if(this.doAccessibleCheck == true){ this.accessible = this.testAccessible(); } } return this.accessible; /* Boolean */ }, testAccessible: function(){ // summary: // Always perform the accessibility check to determine if high // contrast mode is on or display of images are turned off. Currently only checks // in IE and Mozilla. this.accessible = false; //default if (dojo.render.html.ie || dojo.render.html.mozilla){ var div = document.createElement("div"); //div.style.color="rgb(153,204,204)"; div.style.backgroundImage = "url(\"" + this.imgPath + "/tab_close.gif\")"; // must add to hierarchy before can view currentStyle below dojo.body().appendChild(div); // in FF and IE the value for the current background style of the added div // will be "none" in high contrast mode // in FF the return value will be url(invalid-url:) when running over http var bkImg = null; if (window.getComputedStyle ) { var cStyle = getComputedStyle(div, ""); bkImg = cStyle.getPropertyValue("background-image"); }else{ bkImg = div.currentStyle.backgroundImage; } var bUseImgElem = false; if (bkImg != null && (bkImg == "none" || bkImg == "url(invalid-url:)" )) { this.accessible = true; } /* if(this.accessible == false && document.images){ // test if images are off in IE var testImg = new Image(); if(testImg.fileSize) { testImg.src = this.imgPath + "/tab_close.gif"; if(testImg.fileSize < 0){ this.accessible = true; } } }*/ dojo.body().removeChild(div); } return this.accessible; /* Boolean */ }, setCheckAccessible: function(/* Boolean */ bTest){ // summary: // Set whether or not to check for accessibility mode. Default value // of module is true - perform check for accessibility modes. // bTest: Boolean - true to check; false to turn off checking this.doAccessibleCheck = bTest; }, setAccessibleMode: function(){ // summary: // perform the accessibility check and sets the correct mode to load // a11y widgets. Only runs if test for accessiiblity has not been performed yet. // Call testAccessible() to force the test. if (this.accessible === null){ if (this.checkAccessible()){ dojo.render.html.prefixes.unshift("a11y"); } } return this.accessible; /* Boolean */ } }; //dojo.hostenv.modulesLoadedListeners.unshift(function() { dojo.a11y.setAccessibleMode(); }); //dojo.event.connect("before", dojo.hostenv, "makeWidgets", dojo.a11y, "setAccessibleMode"); dojo.provide("dojo.widget.Widget"); dojo.declare("dojo.widget.Widget", null, function(){ // these properties aren't primitives and need to be created on a per-item // basis. // children: Array // a list of all of the widgets that have been added as children of // this component. Should only have values if isContainer is true. this.children = []; // extraArgs: Object // a map of properties which the widget system tried to assign from // user input but did not correspond to any of the properties set on // the class prototype. These names will also be available in all // lower-case form in this map this.extraArgs = {}; }, { // parent: Widget // the parent of this widget parent: null, // isTopLevel: Boolean // should this widget eat all events that bubble up to it? // obviously, top-level and modal widgets should set these appropriately isTopLevel: false, // disabled: Boolean // should this widget respond to user input? // in markup, this is specified as "disabled='disabled'", or just "disabled" disabled: false, // isContainer: Boolean // can this widget contain other widgets? isContainer: false, // widgetId: String // a unique, opaque ID string that can be assigned by users or by the // system. If the developer passes an ID which is known not to be // unique, the specified ID is ignored and the system-generated ID is // used instead. widgetId: "", // widgetType: String // used for building generic widgets widgetType: "Widget", // ns: String // defaults to 'dojo'. "namespace" is a reserved word in JavaScript, so we abbreviate ns: "dojo", getNamespacedType: function(){ // summary: // get the "full" name of the widget. If the widget comes from the // "dojo" namespace and is a Button, calling this method will // return "dojo:button", all lower-case return (this.ns ? this.ns + ":" + this.widgetType : this.widgetType).toLowerCase(); // String }, toString: function(){ // summary: // returns a string that represents the widget. When a widget is // cast to a string, this method will be used to generate the // output. Currently, it does not implement any sort of reversable // serialization. return '[Widget ' + this.getNamespacedType() + ', ' + (this.widgetId || 'NO ID') + ']'; // String }, repr: function(){ // summary: returns the string representation of the widget. return this.toString(); // String }, enable: function(){ // summary: // enables the widget, usually involving unmasking inputs and // turning on event handlers. Not implemented here. this.disabled = false; }, disable: function(){ // summary: // disables the widget, usually involves masking inputs and // unsetting event handlers. Not implemented here. this.disabled = true; }, // TODO: // 1) this would be better in HtmlWidget rather than here? // 2) since many widgets don't care if they've been resized, maybe this should be a mixin? onResized: function(){ // summary: // A signal that widgets will call when they have been resized. // Can be connected to for determining if a layout needs to be // reflowed. Clients should override this function to do special // processing, then call this.notifyChildrenOfResize() to notify // children of resize. this.notifyChildrenOfResize(); }, notifyChildrenOfResize: function(){ // summary: dispatches resized events to all children of this widget for(var i=0; i<this.children.length; i++){ var child = this.children[i]; //dojo.debug(this.widgetId + " resizing child " + child.widgetId); if( child.onResized ){ child.onResized(); } } }, create: function(args, fragment, parent, ns){ // summary: // 'create' manages the initialization part of the widget // lifecycle. It's called implicitly when any widget is created. // All other initialization functions for widgets, except for the // constructor, are called as a result of 'create' being fired. // args: Object // a normalized view of the parameters that the widget should take // fragment: Object // if the widget is being instantiated from markup, this object // parent: Widget? // the widget, if any, that this widget will be the child of. If // none is passed, the global default widget is used. // ns: String? // what namespace the widget belongs to // description: // to understand the process by which widgets are instantiated, it // is critical to understand what other methods 'create' calls and // which of them you'll want to over-ride. Of course, adventurous // developers could over-ride 'create' entirely, but this should // only be done as a last resort. // // Below is a list of the methods that are called, in the order // they are fired, along with notes about what they do and if/when // you should over-ride them in your widget: // // mixInProperties: // takes the args and does lightweight type introspection // on pre-existing object properties to initialize widget // values by casting the values that are passed in args // postMixInProperties: // a stub function that you can over-ride to modify // variables that may have been naively assigned by // mixInProperties // # widget is added to manager object here // buildRendering // subclasses use this method to handle all UI initialization // initialize: // a stub function that you can over-ride. // postInitialize: // a stub function that you can over-ride. // postCreate // a stub function that you can over-ride to modify take // actions once the widget has been placed in the UI // // all of these functions are passed the same arguments as are // passed to 'create' //dojo.profile.start(this.widgetType + " create"); if(ns){ this.ns = ns; } // dojo.debug(this.widgetType, "create"); //dojo.profile.start(this.widgetType + " satisfyPropertySets"); this.satisfyPropertySets(args, fragment, parent); //dojo.profile.end(this.widgetType + " satisfyPropertySets"); // dojo.debug(this.widgetType, "-> mixInProperties"); //dojo.profile.start(this.widgetType + " mixInProperties"); this.mixInProperties(args, fragment, parent); //dojo.profile.end(this.widgetType + " mixInProperties"); // dojo.debug(this.widgetType, "-> postMixInProperties"); //dojo.profile.start(this.widgetType + " postMixInProperties"); this.postMixInProperties(args, fragment, parent); //dojo.profile.end(this.widgetType + " postMixInProperties"); // dojo.debug(this.widgetType, "-> dojo.widget.manager.add"); dojo.widget.manager.add(this); // dojo.debug(this.widgetType, "-> buildRendering"); //dojo.profile.start(this.widgetType + " buildRendering"); this.buildRendering(args, fragment, parent); //dojo.profile.end(this.widgetType + " buildRendering"); // dojo.debug(this.widgetType, "-> initialize"); //dojo.profile.start(this.widgetType + " initialize"); this.initialize(args, fragment, parent); //dojo.profile.end(this.widgetType + " initialize"); // dojo.debug(this.widgetType, "-> postInitialize"); // postinitialize includes subcomponent creation // profile is put directly to function this.postInitialize(args, fragment, parent); // dojo.debug(this.widgetType, "-> postCreate"); //dojo.profile.start(this.widgetType + " postCreate"); this.postCreate(args, fragment, parent); //dojo.profile.end(this.widgetType + " postCreate"); // dojo.debug(this.widgetType, "done!"); //dojo.profile.end(this.widgetType + " create"); return this; }, destroy: function(finalize){ // summary: // Destroy this widget and it's descendants. This is the generic // "destructor" function that all widget users should call to // clealy discard with a widget. Once a widget is destroyed, it's // removed from the manager object. // finalize: Boolean // is this function being called part of global environment // tear-down? // FIXME: this is woefully incomplete if(this.parent){ this.parent.removeChild(this); } this.destroyChildren(); this.uninitialize(); this.destroyRendering(finalize); dojo.widget.manager.removeById(this.widgetId); }, destroyChildren: function(){ // summary: // Recursively destroy the children of this widget and their // descendents. var widget; var i=0; while(this.children.length > i){ widget = this.children[i]; if (widget instanceof dojo.widget.Widget) { // find first widget this.removeChild(widget); widget.destroy(); continue; } i++; // skip data object } }, getChildrenOfType: function(/*String*/type, recurse){ // summary: // return an array of descendant widgets who match the passed type // recurse: Boolean // should we try to get all descendants that match? Defaults to // false. var ret = []; var isFunc = dojo.lang.isFunction(type); if(!isFunc){ type = type.toLowerCase(); } for(var x=0; x<this.children.length; x++){ if(isFunc){ if(this.children[x] instanceof type){ ret.push(this.children[x]); } }else{ if(this.children[x].widgetType.toLowerCase() == type){ ret.push(this.children[x]); } } if(recurse){ ret = ret.concat(this.children[x].getChildrenOfType(type, recurse)); } } return ret; // Array }, getDescendants: function(){ // returns: a flattened array of all direct descendants including self var result = []; var stack = [this]; var elem; while ((elem = stack.pop())){ result.push(elem); // a child may be data object without children field set (not widget) if (elem.children) { dojo.lang.forEach(elem.children, function(elem) { stack.push(elem); }); } } return result; // Array }, isFirstChild: function(){ return this === this.parent.children[0]; // Boolean }, isLastChild: function() { return this === this.parent.children[this.parent.children.length-1]; // Boolean }, satisfyPropertySets: function(args){ // summary: not implemented! // dojo.profile.start("satisfyPropertySets"); // get the default propsets for our component type /* var typePropSets = []; // FIXME: need to pull these from somewhere! var localPropSets = []; // pull out propsets from the parser's return structure // for(var x=0; x<args.length; x++){ // } for(var x=0; x<typePropSets.length; x++){ } for(var x=0; x<localPropSets.length; x++){ } */ // dojo.profile.end("satisfyPropertySets"); return args; }, mixInProperties: function(args, /*Object*/frag){ // summary: // takes the list of properties listed in args and sets values of // the current object based on existence of properties with the // same name (case insensitive) and the type of the pre-existing // property. This is a lightweight conversion and is not intended // to capture custom type semantics. // args: Object // A map of properties and values to set on the current object. By // default it is assumed that properties in args are in string // form and need to be converted. However, if there is a // 'fastMixIn' property with the value 'true' in the args param, // this assumption is ignored and all values in args are copied // directly to the current object without any form of type // casting. // description: // The mix-in code attempts to do some type-assignment based on // PRE-EXISTING properties of the "this" object. When a named // property of args is located, it is first tested to make // sure that the current object already "has one". Properties // which are undefined in the base widget are NOT settable here. // The next step is to try to determine type of the pre-existing // property. If it's a string, the property value is simply // assigned. If a function, it is first cast using "new // Function()" and the execution scope modified such that it // always evaluates in the context of the current object. This // listener is then added to the original function via // dojo.event.connect(). If an Array, the system attempts to split // the string value on ";" chars, and no further processing is // attempted (conversion of array elements to a integers, for // instance). If the property value is an Object // (testObj.constructor === Object), the property is split first // on ";" chars, secondly on ":" chars, and the resulting // key/value pairs are assigned to an object in a map style. The // onus is on the property user to ensure that all property values // are converted to the expected type before usage. Properties // which do not occur in the "this" object are assigned to the // this.extraArgs map using both the original name and the // lower-case name of the property. This allows for consistent // access semantics regardless of the case preservation of the // source of the property names. if((args["fastMixIn"])||(frag["fastMixIn"])){ // dojo.profile.start("mixInProperties_fastMixIn"); // fast mix in assumes case sensitivity, no type casting, etc... // dojo.lang.mixin(this, args); for(var x in args){ this[x] = args[x]; } // dojo.profile.end("mixInProperties_fastMixIn"); return; } // dojo.profile.start("mixInProperties"); var undef; // NOTE: we cannot assume that the passed properties are case-correct // (esp due to some browser bugs). Therefore, we attempt to locate // properties for assignment regardless of case. This may cause // problematic assignments and bugs in the future and will need to be // documented with big bright neon lights. // FIXME: fails miserably if a mixin property has a default value of null in // a widget // NOTE: caching lower-cased args in the prototype is only // acceptable if the properties are invariant. // if we have a name-cache, get it var lcArgs = dojo.widget.lcArgsCache[this.widgetType]; if ( lcArgs == null ){ // build a lower-case property name cache if we don't have one lcArgs = {}; for(var y in this){ lcArgs[((new String(y)).toLowerCase())] = y; } dojo.widget.lcArgsCache[this.widgetType] = lcArgs; } var visited = {}; for(var x in args){ if(!this[x]){ // check the cache for properties var y = lcArgs[(new String(x)).toLowerCase()]; if(y){ args[y] = args[x]; x = y; } } if(visited[x]){ continue; } visited[x] = true; if((typeof this[x]) != (typeof undef)){ if(typeof args[x] != "string"){ this[x] = args[x]; }else{ if(dojo.lang.isString(this[x])){ this[x] = args[x]; }else if(dojo.lang.isNumber(this[x])){ this[x] = new Number(args[x]); // FIXME: what if NaN is the result? }else if(dojo.lang.isBoolean(this[x])){ this[x] = (args[x].toLowerCase()=="false") ? false : true; }else if(dojo.lang.isFunction(this[x])){ // FIXME: need to determine if always over-writing instead // of attaching here is appropriate. I suspect that we // might want to only allow attaching w/ action items. // RAR, 1/19/05: I'm going to attach instead of // over-write here. Perhaps function objects could have // some sort of flag set on them? Or mixed-into objects // could have some list of non-mutable properties // (although I'm not sure how that would alleviate this // particular problem)? // this[x] = new Function(args[x]); // after an IRC discussion last week, it was decided // that these event handlers should execute in the // context of the widget, so that the "this" pointer // takes correctly. // argument that contains no punctuation other than . is // considered a function spec, not code if(args[x].search(/[^\w\.]+/i) == -1){ this[x] = dojo.evalObjPath(args[x], false); }else{ var tn = dojo.lang.nameAnonFunc(new Function(args[x]), this); dojo.event.kwConnect({ srcObj: this, srcFunc: x, adviceObj: this, adviceFunc: tn }); } }else if(dojo.lang.isArray(this[x])){ // typeof [] == "object" this[x] = args[x].split(";"); } else if (this[x] instanceof Date) { this[x] = new Date(Number(args[x])); // assume timestamp }else if(typeof this[x] == "object"){ // FIXME: should we be allowing extension here to handle // other object types intelligently? // if a plain string is passed to a property of type dojo.uri.Uri, // we assume it is relative to root of dojo if (this[x] instanceof dojo.uri.Uri){ this[x] = dojo.uri.dojoUri(args[x]); }else{ // FIXME: unlike all other types, we do not replace the // object with a new one here. Should we change that? var pairs = args[x].split(";"); for(var y=0; y<pairs.length; y++){ var si = pairs[y].indexOf(":"); if((si != -1)&&(pairs[y].length>si)){ this[x][pairs[y].substr(0, si).replace(/^\s+|\s+$/g, "")] = pairs[y].substr(si+1); } } } }else{ // the default is straight-up string assignment. When would // we ever hit this? this[x] = args[x]; } } }else{ // collect any extra 'non mixed in' args this.extraArgs[x.toLowerCase()] = args[x]; } } // dojo.profile.end("mixInProperties"); }, postMixInProperties: function(/*Object*/args, /*Object*/frag, /*Widget*/parent){ // summary // Called after the parameters to the widget have been read-in, // but before the widget template is instantiated. // Especially useful to set properties that are referenced in the widget template. }, initialize: function(/*Object*/args, /*Object*/frag, /*Widget*/parent){ // summary: stub function. return false; // dojo.unimplemented("dojo.widget.Widget.initialize"); }, postInitialize: function(/*Object*/args, /*Object*/frag, /*Widget*/parent){ // summary: stub function. return false; }, postCreate: function(/*Object*/args, /*Object*/frag, /*Widget*/parent){ // summary: stub function. return false; }, uninitialize: function(){ // summary: // stub function. Over-ride to implement custom widget tear-down // behavior. return false; }, buildRendering: function(/*Object*/args, /*Object*/frag, /*Widget*/parent){ // summary: stub function. SUBCLASSES MUST IMPLEMENT dojo.unimplemented("dojo.widget.Widget.buildRendering, on "+this.toString()+", "); return false; }, destroyRendering: function(){ // summary: stub function. SUBCLASSES MUST IMPLEMENT dojo.unimplemented("dojo.widget.Widget.destroyRendering"); return false; }, addedTo: function(parent){ // summary: // stub function this is just a signal that can be caught // parent: Widget // instance of dojo.widget.Widget that we were added to }, addChild: function(child){ // summary: stub function. SUBCLASSES MUST IMPLEMENT dojo.unimplemented("dojo.widget.Widget.addChild"); return false; }, // Detach the given child widget from me, but don't destroy it removeChild: function(/*Widget*/widget){ // summary: // removes the passed widget instance from this widget but does // not destroy it for(var x=0; x<this.children.length; x++){ if(this.children[x] === widget){ this.children.splice(x, 1); widget.parent=null; break; } } return widget; // Widget }, getPreviousSibling: function(){ // summary: // returns null if this is the first child of the parent, // otherwise returns the next sibling to the "left". var idx = this.getParentIndex(); // first node is idx=0 not found is idx<0 if (idx<=0) return null; return this.parent.children[idx-1]; // Widget }, getSiblings: function(){ // summary: gets an array of all children of our parent, including "this" return this.parent.children; // Array }, getParentIndex: function(){ // summary: what index are we at in the parent's children array? return dojo.lang.indexOf(this.parent.children, this, true); // int }, getNextSibling: function(){ // summary: // returns null if this is the last child of the parent, // otherwise returns the next sibling to the "right". var idx = this.getParentIndex(); if (idx == this.parent.children.length-1){return null;} // last node if (idx < 0){return null;} // not found return this.parent.children[idx+1]; // Widget } }); // Lower case name cache: listing of the lower case elements in each widget. // We can't store the lcArgs in the widget itself because if B subclasses A, // then B.prototype.lcArgs might return A.prototype.lcArgs, which is not what we // want dojo.widget.lcArgsCache = {}; // TODO: should have a more general way to add tags or tag libraries? // TODO: need a default tags class to inherit from for things like getting propertySets // TODO: parse properties/propertySets into component attributes // TODO: parse subcomponents // TODO: copy/clone raw markup fragments/nodes as appropriate dojo.widget.tags = {}; dojo.widget.tags.addParseTreeHandler = function(/*String*/type){ // summary: deprecated! dojo.deprecated("addParseTreeHandler", ". ParseTreeHandlers are now reserved for components. Any unfiltered DojoML tag without a ParseTreeHandler is assumed to be a widget", "0.5"); /* var ltype = type.toLowerCase(); this[ltype] = function(fragment, widgetParser, parentComp, insertionIndex, localProps){ var _ltype = ltype; dojo.profile.start(_ltype); var n = dojo.widget.buildWidgetFromParseTree(ltype, fragment, widgetParser, parentComp, insertionIndex, localProps); dojo.profile.end(_ltype); return n; } */ } //dojo.widget.tags.addParseTreeHandler("dojo:widget"); dojo.widget.tags["dojo:propertyset"] = function(fragment, widgetParser, parentComp){ // FIXME: Is this needed? // FIXME: Not sure that this parses into the structure that I want it to parse into... // FIXME: add support for nested propertySets var properties = widgetParser.parseProperties(fragment["dojo:propertyset"]); } // FIXME: need to add the <dojo:connect /> dojo.widget.tags["dojo:connect"] = function(fragment, widgetParser, parentComp){ var properties = widgetParser.parseProperties(fragment["dojo:connect"]); } // FIXME: if we know the insertion point (to a reasonable location), why then do we: // - create a template node // - clone the template node // - render the clone and set properties // - remove the clone from the render tree // - place the clone // this is quite dumb dojo.widget.buildWidgetFromParseTree = function(/*String*/ type, /*Object*/ frag, /*dojo.widget.Parse*/ parser, /*Widget, optional*/ parentComp, /*int, optional*/ insertionIndex, /*Object*/ localProps){ // summary: creates a tree of widgets from the data structure produced by the first-pass parser (frag) // test for accessibility mode dojo.a11y.setAccessibleMode(); //dojo.profile.start("buildWidgetFromParseTree"); // FIXME: for codepath from createComponentFromScript, we are now splitting a path // that we already split and then joined var stype = type.split(":"); stype = (stype.length == 2) ? stype[1] : type; // FIXME: we don't seem to be doing anything with this! // var propertySets = parser.getPropertySets(frag); var localProperties = localProps || parser.parseProperties(frag[frag["ns"]+":"+stype]); var twidget = dojo.widget.manager.getImplementation(stype,null,null,frag["ns"]); if(!twidget){ throw new Error('cannot find "' + type + '" widget'); }else if (!twidget.create){ throw new Error('"' + type + '" widget object has no "create" method and does not appear to implement *Widget'); } localProperties["dojoinsertionindex"] = insertionIndex; // FIXME: we lose no less than 5ms in construction! var ret = twidget.create(localProperties, frag, parentComp, frag["ns"]); // dojo.profile.end("buildWidgetFromParseTree"); return ret; } dojo.widget.defineWidget = function(widgetClass, renderer, superclasses, init, props){ // summary: Create a widget constructor function (aka widgetClass) // widgetClass: String // the location in the object hierarchy to place the new widget class constructor // renderer: String // usually "html", determines when this delcaration will be used // superclasses: Function||Function[] // can be either a single function or an array of functions to be // mixed in as superclasses. If an array, only the first will be used // to set prototype inheritance. // init: Function // an optional constructor function. Will be called after superclasses are mixed in. // props: Object // a map of properties and functions to extend the class prototype with // This meta-function does parameter juggling for backward compat and overloading // if 4th argument is a string, we are using the old syntax // old sig: widgetClass, superclasses, props (object), renderer (string), init (function) if(dojo.lang.isString(arguments[3])){ dojo.widget._defineWidget(arguments[0], arguments[3], arguments[1], arguments[4], arguments[2]); }else{ // widgetClass var args = [ arguments[0] ], p = 3; if(dojo.lang.isString(arguments[1])){ // renderer, superclass args.push(arguments[1], arguments[2]); }else{ // superclass args.push('', arguments[1]); p = 2; } if(dojo.lang.isFunction(arguments[p])){ // init (function), props (object) args.push(arguments[p], arguments[p+1]); }else{ // props (object) args.push(null, arguments[p]); } dojo.widget._defineWidget.apply(this, args); } } dojo.widget.defineWidget.renderers = "html|svg|vml"; dojo.widget._defineWidget = function(widgetClass /*string*/, renderer /*string*/, superclasses /*function||array*/, init /*function*/, props /*object*/){ // FIXME: uncomment next line to test parameter juggling ... remove when confidence improves // dojo.debug('(c:)' + widgetClass + '\n\n(r:)' + renderer + '\n\n(i:)' + init + '\n\n(p:)' + props); // widgetClass takes the form foo.bar.baz<.renderer>.WidgetName (e.g. foo.bar.baz.WidgetName or foo.bar.baz.html.WidgetName) var module = widgetClass.split("."); var type = module.pop(); // type <= WidgetName, module <= foo.bar.baz<.renderer> var regx = "\\.(" + (renderer ? renderer + '|' : '') + dojo.widget.defineWidget.renderers + ")\\."; var r = widgetClass.search(new RegExp(regx)); module = (r < 0 ? module.join(".") : widgetClass.substr(0, r)); // deprecated in favor of namespace system, remove for 0.5 dojo.widget.manager.registerWidgetPackage(module); var pos = module.indexOf("."); var nsName = (pos > -1) ? module.substring(0,pos) : module; // FIXME: hrm, this might make things simpler //dojo.widget.tags.addParseTreeHandler(nsName+":"+type.toLowerCase()); props=(props)||{}; props.widgetType = type; if((!init)&&(props["classConstructor"])){ init = props.classConstructor; delete props.classConstructor; } dojo.declare(widgetClass, superclasses, init, props); } dojo.provide("dojo.widget.Parse"); // // dojoML parser should be moved out of 'widget', codifying the difference between a 'component' // and a 'widget'. A 'component' being anything that can be generated from a tag. // // a particular dojoML tag would be handled by a registered tagHandler with a hook for a default handler // if the widget system is loaded, a widget builder would be attach itself as the default handler // // widget tags are no longer registered themselves: // they are now arbitrarily namespaced, so we cannot register them all, and the non-prefixed portions // are no longer guaranteed unique // // therefore dojo.widget.tags should go with this parser code out of the widget module // dojo.widget.Parse = function(/*Object*/fragment){ this.propertySetsList = []; this.fragment = fragment; this.createComponents = function(/*Object*/frag, /*Object*/parentComp){ var comps = []; var built = false; // if we have items to parse/create at this level, do it! try{ if(frag && frag.tagName && (frag != frag.nodeRef)){ // these are in fact, not ever for widgets per-se anymore, // but for other markup elements (aka components) var djTags = dojo.widget.tags; // we split so that you can declare multiple // non-destructive components from the same ctor node var tna = String(frag.tagName).split(";"); for(var x=0; x<tna.length; x++){ var ltn = tna[x].replace(/^\s+|\s+$/g, "").toLowerCase(); // FIXME: unsure what this does frag.tagName = ltn; var ret; if(djTags[ltn]){ built = true; ret = djTags[ltn](frag, this, parentComp, frag.index); comps.push(ret); }else{ // we require a namespace prefix, default to dojo: if(ltn.indexOf(":") == -1){ ltn = "dojo:"+ltn; } // FIXME: handling failure condition correctly? // ret = djTags[ltn](frag, this, parentComp, frag.index); ret = dojo.widget.buildWidgetFromParseTree(ltn, frag, this, parentComp, frag.index); if(ret){ built = true; comps.push(ret); } } } } }catch(e){ dojo.debug("dojo.widget.Parse: error:", e); // note, commenting out the next line is breaking several widgets for me // throw e; // IE is such a pain sometimes } // if there's a sub-frag, build widgets from that too if(!built){ comps = comps.concat(this.createSubComponents(frag, parentComp)); } return comps; // Array } this.createSubComponents = function(/*Object*/fragment, /*Object*/parentComp){ // summary: recurses over a raw JavaScript object structure, // and calls the corresponding handler for its normalized tagName if it exists var frag, comps = []; for(var item in fragment){ frag = fragment[item]; if(frag && typeof frag == "object" &&(frag!=fragment.nodeRef) &&(frag!=fragment.tagName) &&(!dojo.dom.isNode(frag))){// needed in IE when we have event.connected to the domNode comps = comps.concat(this.createComponents(frag, parentComp)); } } return comps; // Array } this.parsePropertySets = function(/*Object*/fragment){ // summary: checks the top level of a raw JavaScript object // structure for any propertySets. It stores an array of references to // propertySets that it finds. return []; /* var propertySets = []; for(var item in fragment){ if((fragment[item]["tagName"] == "dojo:propertyset")){ propertySets.push(fragment[item]); } } // FIXME: should we store these propertySets somewhere for later retrieval this.propertySetsList.push(propertySets); return propertySets; */ } this.parseProperties = function(/*Object*/fragment){ // summary: parseProperties checks a raw JavaScript object structure for // properties, and returns a hash of properties that it finds. var properties = {}; for(var item in fragment){ // FIXME: need to check for undefined? // case: its a tagName or nodeRef if((fragment[item] == fragment.tagName)||(fragment[item] == fragment.nodeRef)){ // do nothing }else{ var frag = fragment[item]; if(frag.tagName && dojo.widget.tags[frag.tagName.toLowerCase()]){ // TODO: it isn't a property or property set, it's a fragment, // so do something else // FIXME: needs to be a better/stricter check // TODO: handle xlink:href for external property sets }else if(frag[0] && frag[0].value!="" && frag[0].value!=null){ try{ // FIXME: need to allow more than one provider if(item.toLowerCase() == "dataprovider"){ var _this = this; this.getDataProvider(_this, frag[0].value); properties.dataProvider = this.dataProvider; } properties[item] = frag[0].value; var nestedProperties = this.parseProperties(frag); // FIXME: this kind of copying is expensive and inefficient! for(var property in nestedProperties){ properties[property] = nestedProperties[property]; } }catch(e){ dojo.debug(e); } } switch(item.toLowerCase()){ case "checked": case "disabled": if (typeof properties[item] != "boolean"){ properties[item] = true; } break; } } } return properties; // Object } this.getDataProvider = function(/*Object*/objRef, /*String*/dataUrl){ // FIXME: this is currently sync. To make this async, we made need to move //this step into the widget ctor, so that it is loaded when it is needed // to populate the widget dojo.io.bind({ url: dataUrl, load: function(type, evaldObj){ if(type=="load"){ objRef.dataProvider = evaldObj; } }, mimetype: "text/javascript", sync: true }); } this.getPropertySetById = function(propertySetId){ // summary: returns the propertySet that matches the provided id for(var x = 0; x < this.propertySetsList.length; x++){ if(propertySetId == this.propertySetsList[x]["id"][0].value){ return this.propertySetsList[x]; } } return ""; // String } //FIXME: doesn't use the componentType param? this.getPropertySetsByType = function(componentType){ // summary: returns the propertySet(s) that match(es) the // provided componentClass var propertySets = []; for(var x=0; x < this.propertySetsList.length; x++){ var cpl = this.propertySetsList[x]; var cpcc = cpl.componentClass || cpl.componentType || null; //FIXME: is componentType supposed to be an indirect reference? var propertySetId = this.propertySetsList[x]["id"][0].value; if(cpcc && (propertySetId == cpcc[0].value)){ propertySets.push(cpl); } } return propertySets; // Array } this.getPropertySets = function(/*Object*/fragment){ // summary: returns the propertySet for a given component fragment var ppl = "dojo:propertyproviderlist"; var propertySets = []; var tagname = fragment.tagName; if(fragment[ppl]){ var propertyProviderIds = fragment[ppl].value.split(" "); // FIXME: should the propertyProviderList attribute contain # // syntax for reference to ids or not? // FIXME: need a better test to see if this is local or external // FIXME: doesn't handle nested propertySets, or propertySets that // just contain information about css documents, etc. for(var propertySetId in propertyProviderIds){ if((propertySetId.indexOf("..")==-1)&&(propertySetId.indexOf("://")==-1)){ // get a reference to a propertySet within the current parsed structure var propertySet = this.getPropertySetById(propertySetId); if(propertySet != ""){ propertySets.push(propertySet); } }else{ // FIXME: add code to parse and return a propertySet from // another document // alex: is this even necessaray? Do we care? If so, why? } } } // we put the typed ones first so that the parsed ones override when // iteration happens. return this.getPropertySetsByType(tagname).concat(propertySets); // Array } this.createComponentFromScript = function(/*Node*/nodeRef, /*String*/componentName, /*Object*/properties, /*String?*/ns){ // summary: // nodeRef: the node to be replaced... in the future, we might want to add // an alternative way to specify an insertion point // componentName: the expected dojo widget name, i.e. Button of ContextMenu // properties: an object of name value pairs // ns: the namespace of the widget. Defaults to "dojo" properties.fastMixIn = true; // FIXME: we pulled it apart and now we put it back together ... var ltn = (ns || "dojo") + ":" + componentName.toLowerCase(); if(dojo.widget.tags[ltn]){ return [dojo.widget.tags[ltn](properties, this, null, null, properties)]; // Array } return [dojo.widget.buildWidgetFromParseTree(ltn, properties, this, null, null, properties)]; // Array } } dojo.widget._parser_collection = {"dojo": new dojo.widget.Parse() }; dojo.widget.getParser = function(/*String?*/name){ if(!name){ name = "dojo"; } if(!this._parser_collection[name]){ this._parser_collection[name] = new dojo.widget.Parse(); } return this._parser_collection[name]; } dojo.widget.createWidget = function(/*String*/name, /*String*/props, /*Node*/refNode, /*String*/position){ // summary: Creates widget // name: The name of the widget to create with optional namespace prefix, // e.g."ns:widget", namespace defaults to "dojo". // props: Key-Value pairs of properties of the widget // refNode: If the position argument is specified, this node is used as // a reference for inserting this node into a DOM tree; else // the widget becomes the domNode // position: The position to insert this widget's node relative to the // refNode argument var isNode = false; var isNameStr = (typeof name == "string"); if(isNameStr){ var pos = name.indexOf(":"); var ns = (pos > -1) ? name.substring(0,pos) : "dojo"; if(pos > -1){ name = name.substring(pos+1); } var lowerCaseName = name.toLowerCase(); var namespacedName = ns + ":" + lowerCaseName; isNode = (dojo.byId(name) && !dojo.widget.tags[namespacedName]); } if((arguments.length == 1) && (isNode || !isNameStr)){ // we got a DOM node var xp = new dojo.xml.Parse(); // FIXME: we should try to find the parent! var tn = isNode ? dojo.byId(name) : name; return dojo.widget.getParser().createComponents(xp.parseElement(tn, null, true))[0]; } function fromScript(placeKeeperNode, name, props, ns){ props[namespacedName] = { dojotype: [{value: lowerCaseName}], nodeRef: placeKeeperNode, fastMixIn: true }; props.ns = ns; return dojo.widget.getParser().createComponentFromScript(placeKeeperNode, name, props, ns); } props = props||{}; var notRef = false; var tn = null; var h = dojo.render.html.capable; if(h){ tn = document.createElement("span"); } if(!refNode){ notRef = true; refNode = tn; if(h){ dojo.body().appendChild(refNode); } }else if(position){ dojo.dom.insertAtPosition(tn, refNode, position); }else{ // otherwise don't replace, but build in-place tn = refNode; } var widgetArray = fromScript(tn, name.toLowerCase(), props, ns); if( (!widgetArray)||(!widgetArray[0])|| (typeof widgetArray[0].widgetType == "undefined") ){ throw new Error("createWidget: Creation of \"" + name + "\" widget failed."); } try{ if(notRef && widgetArray[0].domNode.parentNode){ widgetArray[0].domNode.parentNode.removeChild(widgetArray[0].domNode); } }catch(e){ /* squelch for Safari */ dojo.debug(e); } return widgetArray[0]; // Widget } 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.widget.DomWidget"); dojo.widget._cssFiles = {}; dojo.widget._cssStrings = {}; dojo.widget._templateCache = {}; dojo.widget.defaultStrings = { // summary: a mapping of strings that are used in template variable replacement dojoRoot: dojo.hostenv.getBaseScriptUri(), dojoWidgetModuleUri: dojo.uri.moduleUri("dojo.widget"), baseScriptUri: dojo.hostenv.getBaseScriptUri() }; dojo.widget.fillFromTemplateCache = function(obj, templatePath, templateString, avoidCache){ // summary: // static method to build from a template w/ or w/o a real widget in // place // obj: DomWidget // an instance of dojo.widget.DomWidget to initialize the template for // templatePath: String // the URL to get the template from. dojo.uri.Uri is often passed as well. // templateString: String? // a string to use in lieu of fetching the template from a URL // avoidCache: Boolean? // should the template system not use whatever is in the cache and // always use the passed templatePath or templateString? // dojo.debug("avoidCache:", avoidCache); var tpath = templatePath || obj.templatePath; var tmplts = dojo.widget._templateCache; if(!tpath && !obj["widgetType"]) { // don't have a real template here do { var dummyName = "__dummyTemplate__" + dojo.widget._templateCache.dummyCount++; } while(tmplts[dummyName]); obj.widgetType = dummyName; } var wt = tpath?tpath.toString():obj.widgetType; var ts = tmplts[wt]; if(!ts){ tmplts[wt] = {"string": null, "node": null}; if(avoidCache){ ts = {}; }else{ ts = tmplts[wt]; } } if((!obj.templateString)&&(!avoidCache)){ obj.templateString = templateString || ts["string"]; } if(obj.templateString){ obj.templateString = this._sanitizeTemplateString(obj.templateString); } if((!obj.templateNode)&&(!avoidCache)){ obj.templateNode = ts["node"]; } if((!obj.templateNode)&&(!obj.templateString)&&(tpath)){ // fetch a text fragment and assign it to templateString // NOTE: we rely on blocking IO here! var tstring = this._sanitizeTemplateString(dojo.hostenv.getText(tpath)); obj.templateString = tstring; if(!avoidCache){ tmplts[wt]["string"] = tstring; } } if((!ts["string"])&&(!avoidCache)){ ts.string = obj.templateString; } } dojo.widget._sanitizeTemplateString = function(/*String*/tString){ //summary: Strips <?xml ...?> declarations so that external SVG and XML //documents can be added to a document without worry. Also, if the string //is an HTML document, only the part inside the body tag is returned. if(tString){ tString = tString.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, ""); var matches = tString.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im); if(matches){ tString = matches[1]; } }else{ tString = ""; } return tString; //String } dojo.widget._templateCache.dummyCount = 0; // Array: list of properties to search for node-to-property mappings dojo.widget.attachProperties = ["dojoAttachPoint", "id"]; // String: name of the property to use for mapping DOM events to widget functions dojo.widget.eventAttachProperty = "dojoAttachEvent"; // String: property name of code to evaluate when the widget is constructed dojo.widget.onBuildProperty = "dojoOnBuild"; // Array: possible accessibility values to set on widget elements - role or state dojo.widget.waiNames = ["waiRole", "waiState"]; dojo.widget.wai = { // summary: Contains functions to set accessibility roles and states // onto widget elements waiRole: { // name: String: // information for mapping accessibility role name: "waiRole", // namespace: String: // URI of the namespace for the set of roles "namespace": "http://www.w3.org/TR/xhtml2", // alias: String: // The alias to assign the namespace alias: "x2", // prefix: String: // The prefix to assign to the role value prefix: "wairole:" }, waiState: { // name: String: // information for mapping accessibility state name: "waiState", // namespace: String: // URI of the namespace for the set of states "namespace": "http://www.w3.org/2005/07/aaa", // alias: String: // The alias to assign the namespace alias: "aaa", // prefix: String: // empty string - state value does not require prefix prefix: "" }, setAttr: function(/*DomNode*/node, /*String*/ ns, /*String*/ attr, /*String|Boolean*/value){ // summary: Use appropriate API to set the role or state attribute onto the element. // description: In IE use the generic setAttribute() api. Append a namespace // alias to the attribute name and appropriate prefix to the value. // Otherwise, use the setAttribueNS api to set the namespaced attribute. Also // add the appropriate prefix to the attribute value. if(dojo.render.html.ie){ node.setAttribute(this[ns].alias+":"+ attr, this[ns].prefix+value); }else{ node.setAttributeNS(this[ns]["namespace"], attr, this[ns].prefix+value); } }, getAttr: function(/*DomNode*/ node, /*String*/ ns, /*String|Boolena*/ attr){ // Summary: Use the appropriate API to retrieve the role or state value // Description: In IE use the generic getAttribute() api. An alias value // was added to the attribute name to simulate a namespace when the attribute // was set. Otherwise use the getAttributeNS() api to retrieve the state value if(dojo.render.html.ie){ return node.getAttribute(this[ns].alias+":"+attr); }else{ return node.getAttributeNS(this[ns]["namespace"], attr); } }, removeAttr: function(/*DomNode*/ node, /*String*/ ns, /*String|Boolena*/ attr){ // summary: Use the appropriate API to remove the role or state value // description: In IE use the generic removeAttribute() api. An alias value // was added to the attribute name to simulate a namespace when the attribute // was set. Otherwise use the removeAttributeNS() api to remove the state value var success = true; //only IE returns a value if(dojo.render.html.ie){ success = node.removeAttribute(this[ns].alias+":"+attr); }else{ node.removeAttributeNS(this[ns]["namespace"], attr); } return success; } }; dojo.widget.attachTemplateNodes = function(rootNode, /*Widget*/ targetObj, events ){ // summary: // map widget properties and functions to the handlers specified in // the dom node and it's descendants. This function iterates over all // nodes and looks for these properties: // * dojoAttachPoint // * dojoAttachEvent // * waiRole // * waiState // * any "dojoOn*" proprties passed in the events array // rootNode: DomNode // the node to search for properties. All children will be searched. // events: Array // a list of properties generated from getDojoEventsFromStr. // FIXME: this method is still taking WAAAY too long. We need ways of optimizing: // a.) what we are looking for on each node // b.) the nodes that are subject to interrogation (use xpath instead?) // c.) how expensive event assignment is (less eval(), more connect()) // var start = new Date(); var elementNodeType = dojo.dom.ELEMENT_NODE; function trim(str){ return str.replace(/^\s+|\s+$/g, ""); } if(!rootNode){ rootNode = targetObj.domNode; } if(rootNode.nodeType != elementNodeType){ return; } // alert(events.length); var nodes = rootNode.all || rootNode.getElementsByTagName("*"); var _this = targetObj; for(var x=-1; x<nodes.length; x++){ var baseNode = (x == -1) ? rootNode : nodes[x]; // FIXME: is this going to have capitalization problems? Could use getAttribute(name, 0); to get attributes case-insensitve var attachPoint = []; if(!targetObj.widgetsInTemplate || !baseNode.getAttribute('dojoType')){ for(var y=0; y<this.attachProperties.length; y++){ var tmpAttachPoint = baseNode.getAttribute(this.attachProperties[y]); if(tmpAttachPoint){ attachPoint = tmpAttachPoint.split(";"); for(var z=0; z<attachPoint.length; z++){ if(dojo.lang.isArray(targetObj[attachPoint[z]])){ targetObj[attachPoint[z]].push(baseNode); }else{ targetObj[attachPoint[z]]=baseNode; } } break; } } var attachEvent = baseNode.getAttribute(this.eventAttachProperty); if(attachEvent){ // NOTE: we want to support attributes that have the form // "domEvent: nativeEvent; ..." var evts = attachEvent.split(";"); for(var y=0; y<evts.length; y++){ if((!evts[y])||(!evts[y].length)){ continue; } var thisFunc = null; var tevt = trim(evts[y]); if(evts[y].indexOf(":") >= 0){ // oh, if only JS had tuple assignment var funcNameArr = tevt.split(":"); tevt = trim(funcNameArr[0]); thisFunc = trim(funcNameArr[1]); } if(!thisFunc){ thisFunc = tevt; } var tf = function(){ var ntf = new String(thisFunc); return function(evt){ if(_this[ntf]){ _this[ntf](dojo.event.browser.fixEvent(evt, this)); } }; }(); dojo.event.browser.addListener(baseNode, tevt, tf, false, true); // dojo.event.browser.addListener(baseNode, tevt, dojo.lang.hitch(_this, thisFunc)); } } for(var y=0; y<events.length; y++){ //alert(events[x]); var evtVal = baseNode.getAttribute(events[y]); if((evtVal)&&(evtVal.length)){ var thisFunc = null; var domEvt = events[y].substr(4); // clober the "dojo" prefix thisFunc = trim(evtVal); var funcs = [thisFunc]; if(thisFunc.indexOf(";")>=0){ funcs = dojo.lang.map(thisFunc.split(";"), trim); } for(var z=0; z<funcs.length; z++){ if(!funcs[z].length){ continue; } var tf = function(){ var ntf = new String(funcs[z]); return function(evt){ if(_this[ntf]){ _this[ntf](dojo.event.browser.fixEvent(evt, this)); } } }(); dojo.event.browser.addListener(baseNode, domEvt, tf, false, true); // dojo.event.browser.addListener(baseNode, domEvt, dojo.lang.hitch(_this, funcs[z])); } } } } // continue; // FIXME: we need to put this into some kind of lookup structure // instead of direct assignment var tmpltPoint = baseNode.getAttribute(this.templateProperty); if(tmpltPoint){ targetObj[tmpltPoint]=baseNode; } dojo.lang.forEach(dojo.widget.waiNames, function(name){ var wai = dojo.widget.wai[name]; var val = baseNode.getAttribute(wai.name); if(val){ if(val.indexOf('-') == -1){ dojo.widget.wai.setAttr(baseNode, wai.name, "role", val); }else{ // this is a state-value pair var statePair = val.split('-'); dojo.widget.wai.setAttr(baseNode, wai.name, statePair[0], statePair[1]); } } }, this); var onBuild = baseNode.getAttribute(this.onBuildProperty); if(onBuild){ eval("var node = baseNode; var widget = targetObj; "+onBuild); } } } dojo.widget.getDojoEventsFromStr = function(str){ // summary: // generates a list of properties with names that match the form // dojoOn* // str: String // the template string to search // var lstr = str.toLowerCase(); var re = /(dojoOn([a-z]+)(\s?))=/gi; var evts = str ? str.match(re)||[] : []; var ret = []; var lem = {}; for(var x=0; x<evts.length; x++){ if(evts[x].length < 1){ continue; } var cm = evts[x].replace(/\s/, ""); cm = (cm.slice(0, cm.length-1)); if(!lem[cm]){ lem[cm] = true; ret.push(cm); } } return ret; // Array } dojo.declare("dojo.widget.DomWidget", dojo.widget.Widget, function(){ // summary: // dojo.widget.DomWidget is the superclass that provides behavior for all // DOM-based renderers, including HtmlWidget and SvgWidget. DomWidget // implements the templating system that most widget authors use to define // the UI for their widgets. if((arguments.length>0)&&(typeof arguments[0] == "object")){ this.create(arguments[0]); } }, { // templateNode: DomNode // a node that represents the widget template. Pre-empts both templateString and templatePath. templateNode: null, // templateString String: // a string that represents the widget template. Pre-empts the // templatePath. In builds that have their strings "interned", the // templatePath is converted to an inline templateString, thereby // preventing a synchronous network call. templateString: null, // templateCssString String: // a string that represents the CSS for the widgettemplate. // Pre-empts the templateCssPath. In builds that have their // strings "interned", the templateCssPath is converted to an // inline templateCssString, thereby preventing a synchronous // network call. templateCssString: null, // preventClobber Boolean: // should the widget not replace the node from which it was // constructed? Widgets that apply behaviors to pre-existing parts // of a page can be implemented easily by setting this to "true". // In these cases, the domNode property will point to the node // which the widget was created from. preventClobber: false, // domNode DomNode: // this is our visible representation of the widget! Other DOM // Nodes may by assigned to other properties, usually through the // template system's dojoAttachPonit syntax, but the domNode // property is the canonical "top level" node in widget UI. domNode: null, // containerNode DomNode: // holds child elements. "containerNode" is generally set via a // dojoAttachPoint assignment and it designates where widgets that // are defined as "children" of the parent will be placed // visually. containerNode: null, // widgetsInTemplate Boolean: // should we parse the template to find widgets that might be // declared in markup inside it? false by default. widgetsInTemplate: false, addChild: function(/*Widget*/ widget, overrideContainerNode, pos, ref, insertIndex){ // summary: // Process the given child widget, inserting it's dom node as // a child of our dom node // overrideContainerNode: DomNode? // a non-default container node for the widget // pos: String? // can be one of "before", "after", "first", or "last". This // has the same meaning as in dojo.dom.insertAtPosition() // ref: DomNode? // a node to place the widget relative to // insertIndex: int? // DOM index, same meaning as in dojo.dom.insertAtIndex() // returns: the widget that was inserted // FIXME: should we support addition at an index in the children arr and // order the display accordingly? Right now we always append. if(!this.isContainer){ // we aren't allowed to contain other widgets, it seems dojo.debug("dojo.widget.DomWidget.addChild() attempted on non-container widget"); return null; }else{ if(insertIndex == undefined){ insertIndex = this.children.length; } this.addWidgetAsDirectChild(widget, overrideContainerNode, pos, ref, insertIndex); this.registerChild(widget, insertIndex); } return widget; // Widget }, addWidgetAsDirectChild: function(/*Widget*/ widget, overrideContainerNode, pos, ref, insertIndex){ // summary: // Process the given child widget, inserting it's dom node as // a child of our dom node // overrideContainerNode: DomNode // a non-default container node for the widget // pos: String? // can be one of "before", "after", "first", or "last". This // has the same meaning as in dojo.dom.insertAtPosition() // ref: DomNode? // a node to place the widget relative to // insertIndex: int? // DOM index, same meaning as in dojo.dom.insertAtIndex() if((!this.containerNode)&&(!overrideContainerNode)){ this.containerNode = this.domNode; } var cn = (overrideContainerNode) ? overrideContainerNode : this.containerNode; if(!pos){ pos = "after"; } if(!ref){ if(!cn){ cn = dojo.body(); } ref = cn.lastChild; } if(!insertIndex) { insertIndex = 0; } widget.domNode.setAttribute("dojoinsertionindex", insertIndex); // insert the child widget domNode directly underneath my domNode, in the // specified position (by default, append to end) if(!ref){ cn.appendChild(widget.domNode); }else{ // FIXME: was this meant to be the (ugly hack) way to support insert @ index? //dojo.dom[pos](widget.domNode, ref, insertIndex); // CAL: this appears to be the intended way to insert a node at a given position... if (pos == 'insertAtIndex'){ // dojo.debug("idx:", insertIndex, "isLast:", ref === cn.lastChild); dojo.dom.insertAtIndex(widget.domNode, ref.parentNode, insertIndex); }else{ // dojo.debug("pos:", pos, "isLast:", ref === cn.lastChild); if((pos == "after")&&(ref === cn.lastChild)){ cn.appendChild(widget.domNode); }else{ dojo.dom.insertAtPosition(widget.domNode, cn, pos); } } } }, registerChild: function(widget, insertionIndex){ // summary: record that given widget descends from me // widget: Widget // the widget that is now a child // insertionIndex: int // where in the children[] array to place it // we need to insert the child at the right point in the parent's // 'children' array, based on the insertionIndex widget.dojoInsertionIndex = insertionIndex; var idx = -1; for(var i=0; i<this.children.length; i++){ //This appears to fix an out of order issue in the case of mixed //markup and programmatically added children. Previously, if a child //existed from markup, and another child was addChild()d without specifying //any additional parameters, it would end up first in the list, when in fact //it should be after. I can't see cases where this would break things, but //I could see no other obvious solution. -dustin if (this.children[i].dojoInsertionIndex <= insertionIndex){ idx = i; } } this.children.splice(idx+1, 0, widget); widget.parent = this; widget.addedTo(this, idx+1); // If this widget was created programatically, then it was erroneously added // to dojo.widget.manager.topWidgets. Fix that here. delete dojo.widget.manager.topWidgets[widget.widgetId]; }, removeChild: function(/*Widget*/ widget){ // summary: detach child domNode from parent domNode dojo.dom.removeNode(widget.domNode); // remove child widget from parent widget return dojo.widget.DomWidget.superclass.removeChild.call(this, widget); // Widget }, getFragNodeRef: function(frag){ // summary: // returns the source node, if any, that the widget was // declared from // frag: Object // an opaque data structure generated by the first-pass parser if(!frag){return null;} // null if(!frag[this.getNamespacedType()]){ dojo.raise("Error: no frag for widget type " + this.getNamespacedType() + ", id " + this.widgetId + " (maybe a widget has set it's type incorrectly)"); } return frag[this.getNamespacedType()]["nodeRef"]; // DomNode }, postInitialize: function(/*Object*/ args, /*Object*/ frag, /*Widget*/ parentComp){ // summary: // Replace the source domNode with the generated dom // structure, and register the widget with its parent. // This is an implementation of the stub function defined in // dojo.widget.Widget. //dojo.profile.start(this.widgetType + " postInitialize"); var sourceNodeRef = this.getFragNodeRef(frag); // Stick my generated dom into the output tree //alert(this.widgetId + ": replacing " + sourceNodeRef + " with " + this.domNode.innerHTML); if (parentComp && (parentComp.snarfChildDomOutput || !sourceNodeRef)){ // Add my generated dom as a direct child of my parent widget // This is important for generated widgets, and also cases where I am generating an // <li> node that can't be inserted back into the original DOM tree parentComp.addWidgetAsDirectChild(this, "", "insertAtIndex", "", args["dojoinsertionindex"], sourceNodeRef); } else if (sourceNodeRef){ // Do in-place replacement of the my source node with my generated dom if(this.domNode && (this.domNode !== sourceNodeRef)){ this._sourceNodeRef = dojo.dom.replaceNode(sourceNodeRef, this.domNode); } } // Register myself with my parent, or with the widget manager if // I have no parent // TODO: the code below erroneously adds all programatically generated widgets // to topWidgets (since we don't know who the parent is until after creation finishes) if ( parentComp ) { parentComp.registerChild(this, args.dojoinsertionindex); } else { dojo.widget.manager.topWidgets[this.widgetId]=this; } if(this.widgetsInTemplate){ var parser = new dojo.xml.Parse(); var subContainerNode; //TODO: use xpath here? var subnodes = this.domNode.getElementsByTagName("*"); for(var i=0;i<subnodes.length;i++){ if(subnodes[i].getAttribute('dojoAttachPoint') == 'subContainerWidget'){ subContainerNode = subnodes[i]; // break; } if(subnodes[i].getAttribute('dojoType')){ subnodes[i].setAttribute('isSubWidget', true); } } if (this.isContainer && !this.containerNode){ //no containerNode is available, which means a widget is used as a container. find it here and move //all dom nodes defined in the main html page as children of this.domNode into the actual container //widget's node (at this point, the subwidgets defined in the template file is not parsed yet) if(subContainerNode){ var src = this.getFragNodeRef(frag); if (src){ dojo.dom.moveChildren(src, subContainerNode); //do not need to follow children nodes in the main html page, as they //will be dealt with in the subContainerWidget frag['dojoDontFollow'] = true; } }else{ dojo.debug("No subContainerWidget node can be found in template file for widget "+this); } } var templatefrag = parser.parseElement(this.domNode, null, true); // createSubComponents not createComponents because frag has already been created dojo.widget.getParser().createSubComponents(templatefrag, this); //find all the sub widgets defined in the template file of this widget var subwidgets = []; var stack = [this]; var w; while((w = stack.pop())){ for(var i = 0; i < w.children.length; i++){ var cwidget = w.children[i]; if(cwidget._processedSubWidgets || !cwidget.extraArgs['issubwidget']){ continue; } subwidgets.push(cwidget); if(cwidget.isContainer){ stack.push(cwidget); } } } //connect event to this widget/attach dom node for(var i = 0; i < subwidgets.length; i++){ var widget = subwidgets[i]; if(widget._processedSubWidgets){ dojo.debug("This should not happen: widget._processedSubWidgets is already true!"); return; } widget._processedSubWidgets = true; if(widget.extraArgs['dojoattachevent']){ var evts = widget.extraArgs['dojoattachevent'].split(";"); for(var j=0; j<evts.length; j++){ var thisFunc = null; var tevt = dojo.string.trim(evts[j]); if(tevt.indexOf(":") >= 0){ // oh, if only JS had tuple assignment var funcNameArr = tevt.split(":"); tevt = dojo.string.trim(funcNameArr[0]); thisFunc = dojo.string.trim(funcNameArr[1]); } if(!thisFunc){ thisFunc = tevt; } if(dojo.lang.isFunction(widget[tevt])){ dojo.event.kwConnect({ srcObj: widget, srcFunc: tevt, targetObj: this, targetFunc: thisFunc }); }else{ alert(tevt+" is not a function in widget "+widget); } } } if(widget.extraArgs['dojoattachpoint']){ //don't attach widget.domNode here, as we do not know which //dom node we should connect to (in checkbox widget case, //it is inputNode). So we make the widget itself available this[widget.extraArgs['dojoattachpoint']] = widget; } } } //dojo.profile.end(this.widgetType + " postInitialize"); // Expand my children widgets /* dojoDontFollow is important for a very special case * basically if you have a widget that you instantiate from script * and that widget is a container, and it contains a reference to a parent * instance, the parser will start recursively parsing until the browser * complains. So the solution is to set an initialization property of * dojoDontFollow: true and then it won't recurse where it shouldn't */ if(this.isContainer && !frag["dojoDontFollow"]){ //alert("recurse from " + this.widgetId); // build any sub-components with us as the parent dojo.widget.getParser().createSubComponents(frag, this); } }, // method over-ride buildRendering: function(/*Object*/ args, /*Object*/ frag){ // summary: // Construct the UI for this widget, generally from a // template. This can be over-ridden for custom UI creation to // to side-step the template system. This is an // implementation of the stub function defined in // dojo.widget.Widget. // DOM widgets construct themselves from a template var ts = dojo.widget._templateCache[this.widgetType]; // Handle style for this widget here, as even if templatePath // is not set, style specified by templateCssString or templateCssPath // should be applied. templateCssString has higher priority // than templateCssPath if(args["templatecsspath"]){ args["templateCssPath"] = args["templatecsspath"]; } var cpath = args["templateCssPath"] || this.templateCssPath; if(cpath && !dojo.widget._cssFiles[cpath.toString()]){ if((!this.templateCssString)&&(cpath)){ this.templateCssString = dojo.hostenv.getText(cpath); this.templateCssPath = null; } dojo.widget._cssFiles[cpath.toString()] = true; } if((this["templateCssString"])&&(!dojo.widget._cssStrings[this.templateCssString])){ dojo.html.insertCssText(this.templateCssString, null, cpath); dojo.widget._cssStrings[this.templateCssString] = true; } if( (!this.preventClobber)&&( (this.templatePath)|| (this.templateNode)|| ( (this["templateString"])&&(this.templateString.length) )|| ( (typeof ts != "undefined")&&( (ts["string"])||(ts["node"]) ) ) ) ){ // if it looks like we can build the thing from a template, do it! this.buildFromTemplate(args, frag); }else{ // otherwise, assign the DOM node that was the source of the widget // parsing to be the root node this.domNode = this.getFragNodeRef(frag); } this.fillInTemplate(args, frag); // this is where individual widgets // will handle population of data // from properties, remote data // sets, etc. }, buildFromTemplate: function(/*Object*/ args, /*Object*/ frag){ // summary: // Called by buildRendering, creates the actual UI in a DomWidget. // var start = new Date(); // copy template properties if they're already set in the templates object // dojo.debug("buildFromTemplate:", this); var avoidCache = false; if(args["templatepath"]){ // avoidCache = true; args["templatePath"] = args["templatepath"]; } dojo.widget.fillFromTemplateCache( this, args["templatePath"], null, avoidCache); var ts = dojo.widget._templateCache[this.templatePath?this.templatePath.toString():this.widgetType]; if((ts)&&(!avoidCache)){ if(!this.templateString.length){ this.templateString = ts["string"]; } if(!this.templateNode){ this.templateNode = ts["node"]; } } var matches = false; var node = null; // var tstr = new String(this.templateString); var tstr = this.templateString; // attempt to clone a template node, if there is one if((!this.templateNode)&&(this.templateString)){ matches = this.templateString.match(/\$\{([^\}]+)\}/g); if(matches) { // if we do property replacement, don't create a templateNode // to clone from. var hash = this.strings || {}; // FIXME: should this hash of default replacements be cached in // templateString? for(var key in dojo.widget.defaultStrings) { if(dojo.lang.isUndefined(hash[key])) { hash[key] = dojo.widget.defaultStrings[key]; } } // FIXME: this is a lot of string munging. Can we make it faster? for(var i = 0; i < matches.length; i++) { var key = matches[i]; key = key.substring(2, key.length-1); var kval = (key.substring(0, 5) == "this.") ? dojo.lang.getObjPathValue(key.substring(5), this) : hash[key]; var value; if((kval)||(dojo.lang.isString(kval))){ value = new String((dojo.lang.isFunction(kval)) ? kval.call(this, key, this.templateString) : kval); // Safer substitution, see heading "Attribute values" in // http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.3.2 while (value.indexOf("\"") > -1) { value=value.replace("\"","""); } tstr = tstr.replace(matches[i], value); } } }else{ // otherwise, we are required to instantiate a copy of the template // string if one is provided. // FIXME: need to be able to distinguish here what should be done // or provide a generic interface across all DOM implementations // FIMXE: this breaks if the template has whitespace as its first // characters // node = this.createNodesFromText(this.templateString, true); // this.templateNode = node[0].cloneNode(true); // we're optimistic here this.templateNode = this.createNodesFromText(this.templateString, true)[0]; if(!avoidCache){ ts.node = this.templateNode; } } } if((!this.templateNode)&&(!matches)){ dojo.debug("DomWidget.buildFromTemplate: could not create template"); return false; }else if(!matches){ node = this.templateNode.cloneNode(true); if(!node){ return false; } }else{ node = this.createNodesFromText(tstr, true)[0]; } // recurse through the node, looking for, and attaching to, our // attachment points which should be defined on the template node. this.domNode = node; // dojo.profile.start("attachTemplateNodes"); this.attachTemplateNodes(); // dojo.profile.end("attachTemplateNodes"); // relocate source contents to templated container node // this.containerNode must be able to receive children, or exceptions will be thrown if (this.isContainer && this.containerNode){ var src = this.getFragNodeRef(frag); if (src){ dojo.dom.moveChildren(src, this.containerNode); } } }, attachTemplateNodes: function(baseNode, targetObj){ // summary: // hooks up event handlers and property/node linkages. Calls // dojo.widget.attachTemplateNodes to do all the hard work. // baseNode: DomNode // defaults to "this.domNode" // targetObj: Widget // defaults to "this" if(!baseNode){ baseNode = this.domNode; } if(!targetObj){ targetObj = this; } return dojo.widget.attachTemplateNodes(baseNode, targetObj, dojo.widget.getDojoEventsFromStr(this.templateString)); }, fillInTemplate: function(){ // summary: // stub function! sub-classes may use as a default UI // initializer function. The UI rendering will be available by // the time this is called from buildRendering. If // buildRendering is over-ridden, this function may not be // fired! // dojo.unimplemented("dojo.widget.DomWidget.fillInTemplate"); }, // method over-ride destroyRendering: function(){ // summary: UI destructor. Destroy the dom nodes associated w/this widget. try{ dojo.dom.destroyNode(this.domNode); delete this.domNode; }catch(e){ /* squelch! */ } if(this._sourceNodeRef){ try{ dojo.dom.destroyNode(this._sourceNodeRef); }catch(e){ /* squelch! */ } } }, createNodesFromText: function(){ // summary // Attempts to create a set of nodes based on the structure of the passed text. // Implemented in HtmlWidget and SvgWidget. dojo.unimplemented("dojo.widget.DomWidget.createNodesFromText"); } } ); 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.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.html.util"); dojo.html.getElementWindow = function(/* HTMLElement */element){ // summary // Get the window object where the element is placed in. return dojo.html.getDocumentWindow( element.ownerDocument ); // Window } dojo.html.getDocumentWindow = function(doc){ // summary // Get window object associated with document doc // With Safari, there is not wa to retrieve the window from the document, so we must fix it. if(dojo.render.html.safari && !doc._parentWindow){ /* This is a Safari specific function that fix the reference to the parent window from the document object. */ var fix=function(win){ win.document._parentWindow=win; for(var i=0; i<win.frames.length; i++){ fix(win.frames[i]); } } fix(window.top); } //In some IE versions (at least 6.0), document.parentWindow does not return a //reference to the real window object (maybe a copy), so we must fix it as well //We use IE specific execScript to attach the real window reference to //document._parentWindow for later use if(dojo.render.html.ie && window !== document.parentWindow && !doc._parentWindow){ /* In IE 6, only the variable "window" can be used to connect events (others may be only copies). */ doc.parentWindow.execScript("document._parentWindow = window;", "Javascript"); //to prevent memory leak, unset it after use //another possibility is to add an onUnload handler which seems overkill to me (liucougar) var win = doc._parentWindow; doc._parentWindow = null; return win; // Window } return doc._parentWindow || doc.parentWindow || doc.defaultView; // Window } dojo.html.gravity = function(/* HTMLElement */node, /* DOMEvent */e){ // summary // Calculates the mouse's direction of gravity relative to the centre // of the given node. // <p> // If you wanted to insert a node into a DOM tree based on the mouse // position you might use the following code: // <pre> // if (gravity(node, e) & gravity.NORTH) { [insert before]; } // else { [insert after]; } // </pre> // // @param node The node // @param e The event containing the mouse coordinates // @return The directions, NORTH or SOUTH and EAST or WEST. These // are properties of the function. node = dojo.byId(node); var mouse = dojo.html.getCursorPosition(e); with (dojo.html) { var absolute = getAbsolutePosition(node, true); var bb = getBorderBox(node); var nodecenterx = absolute.x + (bb.width / 2); var nodecentery = absolute.y + (bb.height / 2); } with (dojo.html.gravity) { return ((mouse.x < nodecenterx ? WEST : EAST) | (mouse.y < nodecentery ? NORTH : SOUTH)); // integer } } dojo.html.gravity.NORTH = 1; dojo.html.gravity.SOUTH = 1 << 1; dojo.html.gravity.EAST = 1 << 2; dojo.html.gravity.WEST = 1 << 3; dojo.html.overElement = function(/* HTMLElement */element, /* DOMEvent */e){ // summary // Returns whether the mouse is over the passed element. // Element must be display:block (ie, not a <span>) element = dojo.byId(element); var mouse = dojo.html.getCursorPosition(e); var bb = dojo.html.getBorderBox(element); var absolute = dojo.html.getAbsolutePosition(element, true, dojo.html.boxSizing.BORDER_BOX); var top = absolute.y; var bottom = top + bb.height; var left = absolute.x; var right = left + bb.width; return (mouse.x >= left && mouse.x <= right && mouse.y >= top && mouse.y <= bottom ); // boolean } dojo.html.renderedTextContent = function(/* HTMLElement */node){ // summary // Attempts to return the text as it would be rendered, with the line breaks // sorted out nicely. Unfinished. node = dojo.byId(node); 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 var display = "unknown"; try { display = dojo.html.getStyle(node.childNodes[i], "display"); } catch(E) {} switch (display) { case "block": case "list-item": case "run-in": case "table": case "table-row-group": case "table-header-group": case "table-footer-group": case "table-row": case "table-column-group": case "table-column": case "table-cell": case "table-caption": // TODO: this shouldn't insert double spaces on aligning blocks result += "\n"; result += dojo.html.renderedTextContent(node.childNodes[i]); result += "\n"; break; case "none": break; default: if(node.childNodes[i].tagName && node.childNodes[i].tagName.toLowerCase() == "br") { result += "\n"; } else { result += dojo.html.renderedTextContent(node.childNodes[i]); } break; } break; case 3: // TEXT_NODE case 2: // ATTRIBUTE_NODE case 4: // CDATA_SECTION_NODE var text = node.childNodes[i].nodeValue; var textTransform = "unknown"; try { textTransform = dojo.html.getStyle(node, "text-transform"); } catch(E) {} switch (textTransform){ case "capitalize": var words = text.split(' '); for(var i=0; i<words.length; i++){ words[i] = words[i].charAt(0).toUpperCase() + words[i].substring(1); } text = words.join(" "); break; case "uppercase": text = text.toUpperCase(); break; case "lowercase": text = text.toLowerCase(); break; default: break; // leave as is } // TODO: implement switch (textTransform){ case "nowrap": break; case "pre-wrap": break; case "pre-line": break; case "pre": break; // leave as is default: // remove whitespace and collapse first space text = text.replace(/\s+/, " "); if (/\s$/.test(result)) { text.replace(/^\s/, ""); } break; } result += text; break; default: break; } } return result; // string } dojo.html.createNodesFromText = function(/* string */txt, /* boolean? */trim){ // summary // Attempts to create a set of nodes based on the structure of the passed text. if(trim) { txt = txt.replace(/^\s+|\s+$/g, ""); } var tn = dojo.doc().createElement("div"); // tn.style.display = "none"; tn.style.visibility= "hidden"; dojo.body().appendChild(tn); var tableType = "none"; if((/^<t[dh][\s\r\n>]/i).test(txt.replace(/^\s+/))) { txt = "<table><tbody><tr>" + txt + "</tr></tbody></table>"; tableType = "cell"; } else if((/^<tr[\s\r\n>]/i).test(txt.replace(/^\s+/))) { txt = "<table><tbody>" + txt + "</tbody></table>"; tableType = "row"; } else if((/^<(thead|tbody|tfoot)[\s\r\n>]/i).test(txt.replace(/^\s+/))) { txt = "<table>" + txt + "</table>"; tableType = "section"; } tn.innerHTML = txt; if(tn["normalize"]){ tn.normalize(); } var parent = null; switch(tableType) { case "cell": parent = tn.getElementsByTagName("tr")[0]; break; case "row": parent = tn.getElementsByTagName("tbody")[0]; break; case "section": parent = tn.getElementsByTagName("table")[0]; break; default: parent = tn; break; } /* this doesn't make much sense, I'm assuming it just meant trim() so wrap was replaced with trim if(wrap){ var ret = []; // start hack var fc = tn.firstChild; ret[0] = ((fc.nodeValue == " ")||(fc.nodeValue == "\t")) ? fc.nextSibling : fc; // end hack // tn.style.display = "none"; dojo.body().removeChild(tn); return ret; } */ var nodes = []; for(var x=0; x<parent.childNodes.length; x++){ nodes.push(parent.childNodes[x].cloneNode(true)); } tn.style.display = "none"; // FIXME: why do we do this? dojo.html.destroyNode(tn); return nodes; // array } dojo.html.placeOnScreen = function( /* HTMLElement */node, /* integer */desiredX, /* integer */desiredY, /* integer */padding, /* boolean? */hasScroll, /* string? */corners, /* boolean? */tryOnly ){ // summary // Keeps 'node' in the visible area of the screen while trying to // place closest to desiredX, desiredY. The input coordinates are // expected to be the desired screen position, not accounting for // scrolling. If you already accounted for scrolling, set 'hasScroll' // to true. Set padding to either a number or array for [paddingX, paddingY] // to put some buffer around the element you want to position. // Set which corner(s) you want to bind to, such as // // placeOnScreen(node, desiredX, desiredY, padding, hasScroll, "TR") // placeOnScreen(node, [desiredX, desiredY], padding, hasScroll, ["TR", "BL"]) // // The desiredX/desiredY will be treated as the topleft(TL)/topright(TR) or // BottomLeft(BL)/BottomRight(BR) corner of the node. Each corner is tested // and if a perfect match is found, it will be used. Otherwise, it goes through // all of the specified corners, and choose the most appropriate one. // By default, corner = ['TL']. // If tryOnly is set to true, the node will not be moved to the place. // // NOTE: node is assumed to be absolutely or relatively positioned. // // Alternate call sig: // placeOnScreen(node, [x, y], padding, hasScroll) // // Examples: // placeOnScreen(node, 100, 200) // placeOnScreen("myId", [800, 623], 5) // placeOnScreen(node, 234, 3284, [2, 5], true) // TODO: make this function have variable call sigs // kes(node, ptArray, cornerArray, padding, hasScroll) // kes(node, ptX, ptY, cornerA, cornerB, cornerC, paddingArray, hasScroll) if(desiredX instanceof Array || typeof desiredX == "array") { tryOnly = corners; corners = hasScroll; hasScroll = padding; padding = desiredY; desiredY = desiredX[1]; desiredX = desiredX[0]; } if(corners instanceof String || typeof corners == "string"){ corners = corners.split(","); } if(!isNaN(padding)) { padding = [Number(padding), Number(padding)]; } else if(!(padding instanceof Array || typeof padding == "array")) { padding = [0, 0]; } var scroll = dojo.html.getScroll().offset; var view = dojo.html.getViewport(); node = dojo.byId(node); var oldDisplay = node.style.display; node.style.display=""; var bb = dojo.html.getBorderBox(node); var w = bb.width; var h = bb.height; node.style.display=oldDisplay; if(!(corners instanceof Array || typeof corners == "array")){ corners = ['TL']; } var bestx, besty, bestDistance = Infinity, bestCorner; for(var cidex=0; cidex<corners.length; ++cidex){ var corner = corners[cidex]; var match = true; var tryX = desiredX - (corner.charAt(1)=='L' ? 0 : w) + padding[0]*(corner.charAt(1)=='L' ? 1 : -1); var tryY = desiredY - (corner.charAt(0)=='T' ? 0 : h) + padding[1]*(corner.charAt(0)=='T' ? 1 : -1); if(hasScroll) { tryX -= scroll.x; tryY -= scroll.y; } if(tryX < 0){ tryX = 0; match = false; } if(tryY < 0){ tryY = 0; match = false; } var x = tryX + w; if(x > view.width) { x = view.width - w; match = false; } else { x = tryX; } x = Math.max(padding[0], x) + scroll.x; var y = tryY + h; if(y > view.height) { y = view.height - h; match = false; } else { y = tryY; } y = Math.max(padding[1], y) + scroll.y; if(match){ //perfect match, return now bestx = x; besty = y; bestDistance = 0; bestCorner = corner; break; }else{ //not perfect, find out whether it is better than the saved one var dist = Math.pow(x-tryX-scroll.x,2)+Math.pow(y-tryY-scroll.y,2); if(bestDistance > dist){ bestDistance = dist; bestx = x; besty = y; bestCorner = corner; } } } if(!tryOnly){ node.style.left = bestx + "px"; node.style.top = besty + "px"; } return { left: bestx, top: besty, x: bestx, y: besty, dist: bestDistance, corner: bestCorner}; // object } dojo.html.placeOnScreenPoint = function(node, desiredX, desiredY, padding, hasScroll) { dojo.deprecated("dojo.html.placeOnScreenPoint", "use dojo.html.placeOnScreen() instead", "0.5"); return dojo.html.placeOnScreen(node, desiredX, desiredY, padding, hasScroll, ['TL', 'TR', 'BL', 'BR']); } dojo.html.placeOnScreenAroundElement = function( /* HTMLElement */node, /* HTMLElement */aroundNode, /* integer */padding, /* string? */aroundType, /* string? */aroundCorners, /* boolean? */tryOnly ){ // summary // Like placeOnScreen, except it accepts aroundNode instead of x,y // and attempts to place node around it. aroundType (see // dojo.html.boxSizing in html/layout.js) determines which box of the // aroundNode should be used to calculate the outer box. // aroundCorners specify Which corner of aroundNode should be // used to place the node => which corner(s) of node to use (see the // corners parameter in dojo.html.placeOnScreen) // aroundCorners: {'TL': 'BL', 'BL': 'TL'} var best, bestDistance=Infinity; aroundNode = dojo.byId(aroundNode); var oldDisplay = aroundNode.style.display; aroundNode.style.display=""; var mb = dojo.html.getElementBox(aroundNode, aroundType); var aroundNodeW = mb.width; var aroundNodeH = mb.height; var aroundNodePos = dojo.html.getAbsolutePosition(aroundNode, true, aroundType); aroundNode.style.display=oldDisplay; for(var nodeCorner in aroundCorners){ var pos, desiredX, desiredY; var corners = aroundCorners[nodeCorner]; desiredX = aroundNodePos.x + (nodeCorner.charAt(1)=='L' ? 0 : aroundNodeW); desiredY = aroundNodePos.y + (nodeCorner.charAt(0)=='T' ? 0 : aroundNodeH); pos = dojo.html.placeOnScreen(node, desiredX, desiredY, padding, true, corners, true); if(pos.dist == 0){ best = pos; break; }else{ //not perfect, find out whether it is better than the saved one if(bestDistance > pos.dist){ bestDistance = pos.dist; best = pos; } } } if(!tryOnly){ node.style.left = best.left + "px"; node.style.top = best.top + "px"; } return best; // object } dojo.html.scrollIntoView = function(/* HTMLElement */node){ // summary // Scroll the passed node into view, if it is not. if(!node){ return; } // don't rely on that node.scrollIntoView works just because the function is there // it doesnt work in Konqueror or Opera even though the function is there and probably // not safari either // dont like browser sniffs implementations but sometimes you have to use it if(dojo.render.html.ie){ //only call scrollIntoView if there is a scrollbar for this menu, //otherwise, scrollIntoView will scroll the window scrollbar if(dojo.html.getBorderBox(node.parentNode).height <= node.parentNode.scrollHeight){ node.scrollIntoView(false); } }else if(dojo.render.html.mozilla){ // IE, mozilla node.scrollIntoView(false); }else{ var parent = node.parentNode; var parentBottom = parent.scrollTop + dojo.html.getBorderBox(parent).height; var nodeBottom = node.offsetTop + dojo.html.getMarginBox(node).height; if(parentBottom < nodeBottom){ parent.scrollTop += (nodeBottom - parentBottom); }else if(parent.scrollTop > node.offsetTop){ parent.scrollTop -= (parent.scrollTop - node.offsetTop); } } } 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.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.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.*"); dojo.provide("dojo.lfx.toggle"); dojo.lfx.toggle.plain = { show: function(node, duration, easing, callback){ dojo.html.show(node); if(dojo.lang.isFunction(callback)){ callback(); } }, hide: function(node, duration, easing, callback){ dojo.html.hide(node); if(dojo.lang.isFunction(callback)){ callback(); } } } dojo.lfx.toggle.fade = { show: function(node, duration, easing, callback){ dojo.lfx.fadeShow(node, duration, easing, callback).play(); }, hide: function(node, duration, easing, callback){ dojo.lfx.fadeHide(node, duration, easing, callback).play(); } } dojo.lfx.toggle.wipe = { show: function(node, duration, easing, callback){ dojo.lfx.wipeIn(node, duration, easing, callback).play(); }, hide: function(node, duration, easing, callback){ dojo.lfx.wipeOut(node, duration, easing, callback).play(); } } dojo.lfx.toggle.explode = { show: function(node, duration, easing, callback, explodeSrc){ dojo.lfx.explode(explodeSrc||{x:0,y:0,width:0,height:0}, node, duration, easing, callback).play(); }, hide: function(node, duration, easing, callback, explodeSrc){ dojo.lfx.implode(node, explodeSrc||{x:0,y:0,width:0,height:0}, duration, easing, callback).play(); } } dojo.provide("dojo.widget.HtmlWidget"); dojo.declare("dojo.widget.HtmlWidget", dojo.widget.DomWidget, { // summary // Base class for all browser based widgets, or at least "html" widgets. // The meaning of "html" has become unclear; in practice, all widgets derive from this class. // templateCssPath: String // Path to CSS file for this widget templateCssPath: null, // templatePath: String // Path to template (HTML file) for this widget templatePath: null, // lang: String // Language to display this widget in (like en-us). // Defaults to brower's specified preferred language (typically the language of the OS) lang: "", // toggle: String // Controls animation effect for when show() and hide() (or toggle()) are called. // Possible values: "plain", "wipe", "fade", "explode" toggle: "plain", // toggleDuration: Integer // Number of milliseconds for toggle animation effect to complete toggleDuration: 150, initialize: function(args, frag){ // summary: called after the widget is rendered; most subclasses won't override or call this function }, postMixInProperties: function(args, frag){ if(this.lang === ""){this.lang = null;} // now that we know the setting for toggle, get toggle object // (default to plain toggler if user specified toggler not present) this.toggleObj = dojo.lfx.toggle[this.toggle.toLowerCase()] || dojo.lfx.toggle.plain; }, createNodesFromText: function(txt, wrap){ return dojo.html.createNodesFromText(txt, wrap); }, destroyRendering: function(finalize){ try{ if(this.bgIframe){ this.bgIframe.remove(); delete this.bgIframe; } if(!finalize && this.domNode){ dojo.event.browser.clean(this.domNode); } dojo.widget.HtmlWidget.superclass.destroyRendering.call(this); }catch(e){ /* squelch! */ } }, ///////////////////////////////////////////////////////// // Displaying/hiding the widget ///////////////////////////////////////////////////////// isShowing: function(){ // summary // Tests whether widget is set to show-mode or hide-mode (see show() and // hide() methods) // // This function is poorly named. Even if widget is in show-mode, // if it's inside a container that's hidden // (either a container widget, or just a domnode with display:none), // then it won't be displayed return dojo.html.isShowing(this.domNode); // Boolean }, toggleShowing: function(){ // summary: show or hide the widget, to switch it's state if(this.isShowing()){ this.hide(); }else{ this.show(); } }, show: function(){ // summary: show the widget if(this.isShowing()){ return; } this.animationInProgress=true; this.toggleObj.show(this.domNode, this.toggleDuration, null, dojo.lang.hitch(this, this.onShow), this.explodeSrc); }, onShow: function(){ // summary: called after the show() animation has completed this.animationInProgress=false; this.checkSize(); }, hide: function(){ // summary: hide the widget (ending up with display:none) if(!this.isShowing()){ return; } this.animationInProgress = true; this.toggleObj.hide(this.domNode, this.toggleDuration, null, dojo.lang.hitch(this, this.onHide), this.explodeSrc); }, onHide: function(){ // summary: called after the hide() animation has completed this.animationInProgress=false; }, ////////////////////////////////////////////////////////////////////////////// // Sizing related methods // If the parent changes size then for each child it should call either // - resizeTo(): size the child explicitly // - or checkSize(): notify the child the the parent has changed size ////////////////////////////////////////////////////////////////////////////// _isResized: function(w, h){ // summary // Test if my size has changed. // If width & height are specified then that's my new size; otherwise, // query outerWidth/outerHeight of my domNode // If I'm not being displayed then disregard (show() must // check if the size has changed) if(!this.isShowing()){ return false; } // If my parent has been resized and I have style="height: 100%" // or something similar then my size has changed too. var wh = dojo.html.getMarginBox(this.domNode); var width=w||wh.width; var height=h||wh.height; if(this.width == width && this.height == height){ return false; } this.width=width; this.height=height; return true; }, checkSize: function(){ // summary // Called when my parent has changed size, but my parent won't call resizeTo(). // This is useful if my size is height:100% or something similar. // Also called whenever I am shown, because the first time I am shown I may need // to do size calculations. if(!this._isResized()){ return; } this.onResized(); }, resizeTo: function(w, h){ // summary: explicitly set this widget's size (in pixels). dojo.html.setMarginBox(this.domNode, { width: w, height: h }); // can't do sizing if widget is hidden because referencing node.offsetWidth/node.offsetHeight returns 0. // do sizing on show() instead. if(this.isShowing()){ this.onResized(); } }, resizeSoon: function(){ // summary // schedule onResized() to be called soon, after browser has had // a little more time to calculate the sizes if(this.isShowing()){ dojo.lang.setTimeout(this, this.onResized, 0); } }, onResized: function(){ // summary // Called when my size has changed. // Must notify children if their size has (possibly) changed. dojo.lang.forEach(this.children, function(child){ if(child.checkSize){child.checkSize();} }); } }); dojo.kwCompoundRequire({ common: ["dojo.xml.Parse", "dojo.widget.Widget", "dojo.widget.Parse", "dojo.widget.Manager"], browser: ["dojo.widget.DomWidget", "dojo.widget.HtmlWidget"], dashboard: ["dojo.widget.DomWidget", "dojo.widget.HtmlWidget"], svg: ["dojo.widget.SvgWidget"], rhino: ["dojo.widget.SwtWidget"] }); dojo.provide("dojo.widget.*"); dojo.kwCompoundRequire({ common: [ "dojo.html.common", "dojo.html.style" ] }); dojo.provide("dojo.html.*"); dojo.provide("dojo.html.selection"); /** * type of selection **/ dojo.html.selectionType = { NONE : 0, //selection is empty TEXT : 1, //selection contains text (may also contains CONTROL objects) CONTROL : 2 //only one element is selected (such as img, table etc) }; dojo.html.clearSelection = function(){ // summary: deselect the current selection to make it empty var _window = dojo.global(); var _document = dojo.doc(); try{ if(_window["getSelection"]){ if(dojo.render.html.safari){ // pulled from WebCore/ecma/kjs_window.cpp, line 2536 _window.getSelection().collapse(); }else{ _window.getSelection().removeAllRanges(); } }else if(_document.selection){ if(_document.selection.empty){ _document.selection.empty(); }else if(_document.selection.clear){ _document.selection.clear(); } } return true; }catch(e){ dojo.debug(e); return false; } } dojo.html.disableSelection = function(/*DomNode*/element){ // summary: disable selection on a node element = dojo.byId(element)||dojo.body(); var h = dojo.render.html; if(h.mozilla){ element.style.MozUserSelect = "none"; }else if(h.safari){ element.style.KhtmlUserSelect = "none"; }else if(h.ie){ element.unselectable = "on"; }else{ return false; } return true; } dojo.html.enableSelection = function(/*DomNode*/element){ // summary: enable selection on a node element = dojo.byId(element)||dojo.body(); var h = dojo.render.html; if(h.mozilla){ element.style.MozUserSelect = ""; }else if(h.safari){ element.style.KhtmlUserSelect = ""; }else if(h.ie){ element.unselectable = "off"; }else{ return false; } return true; } dojo.html.selectElement = function(/*DomNode*/element){ dojo.deprecated("dojo.html.selectElement", "replaced by dojo.html.selection.selectElementChildren", 0.5); } dojo.html.selectInputText = function(/*DomNode*/element){ // summary: select all the text in an input element var _window = dojo.global(); var _document = dojo.doc(); element = dojo.byId(element); if(_document["selection"] && dojo.body()["createTextRange"]){ // IE var range = element.createTextRange(); range.moveStart("character", 0); range.moveEnd("character", element.value.length); range.select(); }else if(_window["getSelection"]){ var selection = _window.getSelection(); // FIXME: does this work on Safari? element.setSelectionRange(0, element.value.length); } element.focus(); } dojo.html.isSelectionCollapsed = function(){ dojo.deprecated("dojo.html.isSelectionCollapsed", "replaced by dojo.html.selection.isCollapsed", 0.5); return dojo.html.selection.isCollapsed(); } dojo.lang.mixin(dojo.html.selection, { getType: function() { // summary: Get the selection type (like document.select.type in IE). if(dojo.doc()["selection"]){ //IE return dojo.html.selectionType[dojo.doc().selection.type.toUpperCase()]; }else{ var stype = dojo.html.selectionType.TEXT; // Check if the actual selection is a CONTROL (IMG, TABLE, HR, etc...). var oSel; try {oSel = dojo.global().getSelection();} catch (e) {} if(oSel && oSel.rangeCount==1){ var oRange = oSel.getRangeAt(0); if (oRange.startContainer == oRange.endContainer && (oRange.endOffset - oRange.startOffset) == 1 && oRange.startContainer.nodeType != dojo.dom.TEXT_NODE) { stype = dojo.html.selectionType.CONTROL; } } return stype; } }, isCollapsed: function() { // summary: return whether the current selection is empty var _window = dojo.global(); var _document = dojo.doc(); if(_document["selection"]){ // IE return _document.selection.createRange().text == ""; }else if(_window["getSelection"]){ var selection = _window.getSelection(); if(dojo.lang.isString(selection)){ // Safari return selection == ""; }else{ // Mozilla/W3 return selection.isCollapsed || selection.toString() == ""; } } }, getSelectedElement: function() { // summary: // Retrieves the selected element (if any), just in the case that a single // element (object like and image or a table) is selected. if ( dojo.html.selection.getType() == dojo.html.selectionType.CONTROL ){ if(dojo.doc()["selection"]){ //IE var range = dojo.doc().selection.createRange(); if ( range && range.item ){ return dojo.doc().selection.createRange().item(0); } }else{ var selection = dojo.global().getSelection(); return selection.anchorNode.childNodes[ selection.anchorOffset ]; } } }, getParentElement: function() { // summary: // Get the parent element of the current selection if(dojo.html.selection.getType() == dojo.html.selectionType.CONTROL){ var p = dojo.html.selection.getSelectedElement(); if(p){ return p.parentNode; } }else{ if(dojo.doc()["selection"]){ //IE return dojo.doc().selection.createRange().parentElement(); }else{ var selection = dojo.global().getSelection(); if(selection){ var node = selection.anchorNode; while ( node && node.nodeType != dojo.dom.ELEMENT_NODE ){ node = node.parentNode; } return node; } } } }, getSelectedText: function(){ // summary: // Return the text (no html tags) included in the current selection or null if no text is selected if(dojo.doc()["selection"]){ //IE if(dojo.html.selection.getType() == dojo.html.selectionType.CONTROL){ return null; } return dojo.doc().selection.createRange().text; }else{ var selection = dojo.global().getSelection(); if(selection){ return selection.toString(); } } }, getSelectedHtml: function(){ // summary: // Return the html of the current selection or null if unavailable if(dojo.doc()["selection"]){ //IE if(dojo.html.selection.getType() == dojo.html.selectionType.CONTROL){ return null; } return dojo.doc().selection.createRange().htmlText; }else{ var selection = dojo.global().getSelection(); if(selection && selection.rangeCount){ var frag = selection.getRangeAt(0).cloneContents(); var div = document.createElement("div"); div.appendChild(frag); return div.innerHTML; } return null; } }, hasAncestorElement: function(/*String*/tagName /* ... */){ // summary: // Check whether current selection has a parent element which is of type tagName (or one of the other specified tagName) return (dojo.html.selection.getAncestorElement.apply(this, arguments) != null); }, getAncestorElement: function(/*String*/tagName /* ... */){ // summary: // Return the parent element of the current selection which is of type tagName (or one of the other specified tagName) var node = dojo.html.selection.getSelectedElement() || dojo.html.selection.getParentElement(); while(node /*&& node.tagName.toLowerCase() != 'body'*/){ if(dojo.html.selection.isTag(node, arguments).length>0){ return node; } node = node.parentNode; } return null; }, //modified from dojo.html.isTag to take an array as second parameter isTag: function(/*DomNode*/node, /*Array*/tags) { if(node && node.tagName) { for (var i=0; i<tags.length; i++){ if (node.tagName.toLowerCase()==String(tags[i]).toLowerCase()){ return String(tags[i]).toLowerCase(); } } } return ""; }, selectElement: function(/*DomNode*/element) { // summary: clear previous selection and select element (including all its children) var _window = dojo.global(); var _document = dojo.doc(); element = dojo.byId(element); if(_document.selection && dojo.body().createTextRange){ // IE try{ var range = dojo.body().createControlRange(); range.addElement(element); range.select(); }catch(e){ dojo.html.selection.selectElementChildren(element); } }else if(_window["getSelection"]){ var selection = _window.getSelection(); // FIXME: does this work on Safari? if(selection["removeAllRanges"]){ // Mozilla var range = _document.createRange() ; range.selectNode(element) ; selection.removeAllRanges() ; selection.addRange(range) ; } } }, selectElementChildren: function(/*DomNode*/element){ // summary: clear previous selection and select the content of the node (excluding the node itself) var _window = dojo.global(); var _document = dojo.doc(); element = dojo.byId(element); if(_document.selection && dojo.body().createTextRange){ // IE var range = dojo.body().createTextRange(); range.moveToElementText(element); range.select(); }else if(_window["getSelection"]){ var selection = _window.getSelection(); if(selection["setBaseAndExtent"]){ // Safari selection.setBaseAndExtent(element, 0, element, element.innerText.length - 1); } else if(selection["selectAllChildren"]){ // Mozilla selection.selectAllChildren(element); } } }, getBookmark: function(){ // summary: Retrieves a bookmark that can be used with moveToBookmark to return to the same range var bookmark; var _document = dojo.doc(); if(_document["selection"]){ // IE var range = _document.selection.createRange(); bookmark = range.getBookmark(); }else{ var selection; try {selection = dojo.global().getSelection();} catch (e) {} if(selection){ var range = selection.getRangeAt(0); bookmark = range.cloneRange(); }else{ dojo.debug("No idea how to store the current selection for this browser!"); } } return bookmark; }, moveToBookmark: function(/*Object*/bookmark){ // summary: Moves current selection to a bookmark // bookmark: this should be a returned object from dojo.html.selection.getBookmark() var _document = dojo.doc(); if(_document["selection"]){ // IE var range = _document.selection.createRange(); range.moveToBookmark(bookmark); range.select(); }else{ //Moz/W3C var selection; try {selection = dojo.global().getSelection();} catch (e) {} if(selection && selection['removeAllRanges']){ selection.removeAllRanges() ; selection.addRange(bookmark) ; }else{ dojo.debug("No idea how to restore selection for this browser!"); } } }, collapse: function(/*Boolean*/beginning) { // summary: clear current selection if(dojo.global()['getSelection']){ var selection = dojo.global().getSelection(); if(selection.removeAllRanges){ // Mozilla if(beginning){ selection.collapseToStart(); }else{ selection.collapseToEnd(); } }else{ // Safari // pulled from WebCore/ecma/kjs_window.cpp, line 2536 dojo.global().getSelection().collapse(beginning); } }else if(dojo.doc().selection){ // IE var range = dojo.doc().selection.createRange(); range.collapse(beginning); range.select(); } }, remove: function() { // summary: delete current selection if(dojo.doc().selection) { //IE var selection = dojo.doc().selection; if ( selection.type.toUpperCase() != "NONE" ){ selection.clear(); } return selection; }else{ var selection = dojo.global().getSelection(); for ( var i = 0; i < selection.rangeCount; i++ ){ selection.getRangeAt(i).deleteContents(); } return selection; } } }); dojo.provide("dojo.widget.Button"); /* * usage * <button dojoType="button" onClick="...">Hello world</button> * * var button1 = dojo.widget.createWidget("Button", {caption: "hello world", onClick: foo}); * document.body.appendChild(button1.domNode); */ dojo.widget.defineWidget( "dojo.widget.Button", dojo.widget.HtmlWidget, { // summary // Basically the same thing as a normal HTML button, but with special styling. isContainer: true, // caption: String // text to display in button caption: "", templateString:"<div dojoAttachPoint=\"buttonNode\" class=\"dojoButton\" style=\"position:relative;\" dojoAttachEvent=\"onMouseOver; onMouseOut; onMouseDown; onMouseUp; onClick:buttonClick; onKey:onKey; onFocus;\">\r\n <div class=\"dojoButtonContents\" align=center dojoAttachPoint=\"containerNode\" style=\"position:absolute;z-index:2;\"></div>\r\n <img dojoAttachPoint=\"leftImage\" style=\"position:absolute;left:0px;\">\r\n <img dojoAttachPoint=\"centerImage\" style=\"position:absolute;z-index:1;\">\r\n <img dojoAttachPoint=\"rightImage\" style=\"position:absolute;top:0px;right:0px;\">\r\n</div>\r\n", templateCssString:"/* ---- button --- */\r\n.dojoButton {\r\n\tpadding: 0 0 0 0;\r\n\tfont-size: 8pt;\r\n\twhite-space: nowrap;\r\n\tcursor: pointer;\r\n\tfont-family: Myriad, Tahoma, Verdana, sans-serif;\r\n}\r\n\r\n.dojoButton .dojoButtonContents {\r\n\tpadding: 2px 2px 2px 2px;\r\n\ttext-align: center;\t\t/* if icon and label are split across two lines, center icon */\r\n\tcolor: white;\r\n}\r\n\r\n.dojoButtonLeftPart .dojoButtonContents {\r\n\tpadding-right: 8px;\r\n}\r\n\r\n.dojoButtonDisabled {\r\n\tcursor: url(\"images/no.gif\"), default;\r\n}\r\n\r\n\r\n.dojoButtonContents img {\r\n\tvertical-align: middle;\t/* if icon and label are on same line, center them */\r\n}\r\n\r\n/* -------- colors ------------ */\r\n\r\n.dojoButtonHover .dojoButtonContents {\r\n}\r\n\r\n.dojoButtonDepressed .dojoButtonContents {\r\n\tcolor: #293a4b;\r\n}\r\n\r\n.dojoButtonDisabled .dojoButtonContents {\r\n\tcolor: #aaa;\r\n}\r\n\r\n\r\n/* ---------- drop down button specific ---------- */\r\n\r\n/* border between label and arrow (for drop down buttons */\r\n.dojoButton .border {\r\n\twidth: 1px;\r\n\tbackground: gray;\r\n}\r\n\r\n/* button arrow */\r\n.dojoButton .downArrow {\r\n\tpadding-left: 10px;\r\n\ttext-align: center;\r\n}\r\n\r\n.dojoButton.disabled .downArrow {\r\n\tcursor : default;\r\n}\r\n",templateCssPath: dojo.uri.moduleUri("dojo.widget", "templates/ButtonTemplate.css"), // inactiveImg: Url // prefix of filename holding images (left, center, right) for button in normal state inactiveImg: "templates/images/soriaButton-", // activeImg: Url // prefix of filename holding images (left, center, right) for button when it's being hovered over activeImg: "templates/images/soriaActive-", // pressedImg: Url // prefix of filename holding images (left, center, right) for button between mouse-down and mouse-up pressedImg: "templates/images/soriaPressed-", // disabledImg: Url // prefix of filename holding images (left, center, right) for button when it's disabled (aka, grayed-out) disabledImg: "templates/images/soriaDisabled-", // widget2height: Number // shape of the button's end pieces; // the height of the end pieces is a function of the button's height (which in turn is a function of the button's content), // and then the width of the end pieces is relative to their height. width2height: 1.0/3.0, fillInTemplate: function(){ if(this.caption){ this.containerNode.appendChild(document.createTextNode(this.caption)); } dojo.html.disableSelection(this.containerNode); }, postCreate: function(){ this._sizeMyself(); }, _sizeMyself: function(){ // we cannot size correctly if any of our ancestors are hidden (display:none), // so temporarily attach to document.body if(this.domNode.parentNode){ var placeHolder = document.createElement("span"); dojo.html.insertBefore(placeHolder, this.domNode); } dojo.body().appendChild(this.domNode); this._sizeMyselfHelper(); // Put this.domNode back where it was originally if(placeHolder){ dojo.html.insertBefore(this.domNode, placeHolder); dojo.html.removeNode(placeHolder); } }, _sizeMyselfHelper: function(){ var mb = dojo.html.getMarginBox(this.containerNode); this.height = mb.height; this.containerWidth = mb.width; var endWidth= this.height * this.width2height; this.containerNode.style.left=endWidth+"px"; this.leftImage.height = this.rightImage.height = this.centerImage.height = this.height; this.leftImage.width = this.rightImage.width = endWidth+1; this.centerImage.width = this.containerWidth; this.centerImage.style.left=endWidth+"px"; this._setImage(this.disabled ? this.disabledImg : this.inactiveImg); if ( this.disabled ) { dojo.html.prependClass(this.domNode, "dojoButtonDisabled"); this.domNode.removeAttribute("tabIndex"); dojo.widget.wai.setAttr(this.domNode, "waiState", "disabled", true); } else { dojo.html.removeClass(this.domNode, "dojoButtonDisabled"); this.domNode.setAttribute("tabIndex", "0"); dojo.widget.wai.setAttr(this.domNode, "waiState", "disabled", false); } this.domNode.style.height=this.height + "px"; this.domNode.style.width= (this.containerWidth+2*endWidth) + "px"; }, onMouseOver: function(/*Event*/ e){ // summary: callback when user mouses-over the button if( this.disabled ){ return; } if (!dojo.html.hasClass(this.buttonNode, "dojoButtonHover")){ dojo.html.prependClass(this.buttonNode, "dojoButtonHover"); } this._setImage(this.activeImg); }, onMouseDown: function(/*Event*/ e){ // summary: callback when user starts to click the button if( this.disabled ){ return; } dojo.html.prependClass(this.buttonNode, "dojoButtonDepressed"); dojo.html.removeClass(this.buttonNode, "dojoButtonHover"); this._setImage(this.pressedImg); }, onMouseUp: function(/*Event*/ e){ // summary: callback when the user finishes clicking if( this.disabled ){ return; } dojo.html.prependClass(this.buttonNode, "dojoButtonHover"); dojo.html.removeClass(this.buttonNode, "dojoButtonDepressed"); this._setImage(this.activeImg); }, onMouseOut: function(/*Event*/ e){ // summary: callback when the user moves the mouse off the button if( this.disabled ){ return; } if( e.toElement && dojo.html.isDescendantOf(e.toElement, this.buttonNode) ){ return; // Ignore IE mouseOut events that dont actually leave button - Prevents hover image flicker in IE } dojo.html.removeClass(this.buttonNode, "dojoButtonHover"); dojo.html.removeClass(this.buttonNode, "dojoButtonDepressed"); this._setImage(this.inactiveImg); }, onKey: function(/*Event*/ e){ // summary: callback when the user presses a key (on key-down) if (!e.key) { return; } var menu = dojo.widget.getWidgetById(this.menuId); if (e.key == e.KEY_ENTER || e.key == " "){ this.onMouseDown(e); this.buttonClick(e); dojo.lang.setTimeout(this, "onMouseUp", 75, e); dojo.event.browser.stopEvent(e); } if(menu && menu.isShowingNow && e.key == e.KEY_DOWN_ARROW){ // disconnect onBlur when focus moves into menu dojo.event.disconnect(this.domNode, "onblur", this, "onBlur"); // allow event to propagate to menu } }, onFocus: function(/*Event*/ e){ // summary: callback on focus to the button var menu = dojo.widget.getWidgetById(this.menuId); if (menu){ dojo.event.connectOnce(this.domNode, "onblur", this, "onBlur"); } }, onBlur: function(/*Event*/ e){ // summary: callback when button loses focus var menu = dojo.widget.getWidgetById(this.menuId); if ( !menu ) { return; } if ( menu.close && menu.isShowingNow ){ menu.close(); } }, buttonClick: function(/*Event*/ e){ // summary: internal function for handling button clicks if(!this.disabled){ // focus may fail when tabIndex is not supported on div's // by the browser, or when the node is disabled try { this.domNode.focus(); } catch(e2) {}; this.onClick(e); } }, onClick: function(/*Event*/ e) { // summary: callback for when button is clicked; user can override this function }, _setImage: function(/*String*/ prefix){ this.leftImage.src=dojo.uri.moduleUri("dojo.widget", prefix + "l.gif"); this.centerImage.src=dojo.uri.moduleUri("dojo.widget", prefix + "c.gif"); this.rightImage.src=dojo.uri.moduleUri("dojo.widget", prefix + "r.gif"); }, _toggleMenu: function(/*String*/ menuId){ var menu = dojo.widget.getWidgetById(menuId); if ( !menu ) { return; } if ( menu.open && !menu.isShowingNow) { var pos = dojo.html.getAbsolutePosition(this.domNode, false); menu.open(pos.x, pos.y+this.height, this); // disconnect onBlur when focus moves into menu dojo.event.disconnect(this.domNode, "onblur", this, "onBlur"); } else if ( menu.close && menu.isShowingNow ){ menu.close(); } else { menu.toggle(); } }, setCaption: function(/*String*/ content){ // summary: reset the caption (text) of the button; takes an HTML string this.caption=content; this.containerNode.innerHTML=content; this._sizeMyself(); }, setDisabled: function(/*Boolean*/ disabled){ // summary: set disabled state of button this.disabled=disabled; this._sizeMyself(); } }); /* * usage * <button dojoType="DropDownButton" menuId="mymenu">Hello world</button> * * var button1 = dojo.widget.createWidget("DropDownButton", {caption: "hello world", menuId: foo}); * document.body.appendChild(button1.domNode); */ dojo.widget.defineWidget( "dojo.widget.DropDownButton", dojo.widget.Button, { // summary // push the button and a menu shows up // menuId: String // widget id of the menu that this button should activate menuId: "", // downArrow: Url // path of arrow image to display to the right of the button text downArrow: "templates/images/whiteDownArrow.gif", // disabledDownArray: Url // path of arrow image to display to the right of the button text, when the button is disabled disabledDownArrow: "templates/images/whiteDownArrow.gif", fillInTemplate: function(){ dojo.widget.DropDownButton.superclass.fillInTemplate.apply(this, arguments); this.arrow = document.createElement("img"); dojo.html.setClass(this.arrow, "downArrow"); dojo.widget.wai.setAttr(this.domNode, "waiState", "haspopup", this.menuId); }, _sizeMyselfHelper: function(){ // draw the arrow (todo: why is the arror in containerNode rather than outside it?) this.arrow.src = dojo.uri.moduleUri("dojo.widget", this.disabled ? this.disabledDownArrow : this.downArrow); this.containerNode.appendChild(this.arrow); dojo.widget.DropDownButton.superclass._sizeMyselfHelper.call(this); }, onClick: function(/*Event*/ e){ // summary: callback when button is clicked; user shouldn't override this function or else the menu won't toggle this._toggleMenu(this.menuId); } }); /* * usage * <button dojoType="ComboButton" onClick="..." menuId="mymenu">Hello world</button> * * var button1 = dojo.widget.createWidget("DropDownButton", {caption: "hello world", onClick: foo, menuId: "myMenu"}); * document.body.appendChild(button1.domNode); */ dojo.widget.defineWidget( "dojo.widget.ComboButton", dojo.widget.Button, { // summary // left side is normal button, right side displays menu // menuId: String // widget id of the menu that this button should activate menuId: "", templateString:"<div class=\"dojoButton\" style=\"position:relative;top:0px;left:0px; text-align:none;\" dojoAttachEvent=\"onKey;onFocus\">\r\n\r\n\t<div dojoAttachPoint=\"buttonNode\" class=\"dojoButtonLeftPart\" style=\"position:absolute;left:0px;top:0px;\"\r\n\t\tdojoAttachEvent=\"onMouseOver; onMouseOut; onMouseDown; onMouseUp; onClick:buttonClick;\">\r\n\t\t<div class=\"dojoButtonContents\" dojoAttachPoint=\"containerNode\" style=\"position:absolute;top:0px;right:0px;z-index:2;\"></div>\r\n\t\t<img dojoAttachPoint=\"leftImage\" style=\"position:absolute;left:0px;top:0px;\">\r\n\t\t<img dojoAttachPoint=\"centerImage\" style=\"position:absolute;right:0px;top:0px;z-index:1;\">\r\n\t</div>\r\n\r\n\t<div dojoAttachPoint=\"rightPart\" class=\"dojoButtonRightPart\" style=\"position:absolute;top:0px;right:0px;\"\r\n\t\tdojoAttachEvent=\"onMouseOver:rightOver; onMouseOut:rightOut; onMouseDown:rightDown; onMouseUp:rightUp; onClick:rightClick;\">\r\n\t\t<img dojoAttachPoint=\"arrowBackgroundImage\" style=\"position:absolute;top:0px;left:0px;z-index:1;\">\r\n\t\t<img src=\"${dojoWidgetModuleUri}templates/images/whiteDownArrow.gif\"\r\n\t\t \t\tstyle=\"z-index:2;position:absolute;left:3px;top:50%;\">\r\n\t\t<img dojoAttachPoint=\"rightImage\" style=\"position:absolute;top:0px;right:0px;\">\r\n\t</div>\r\n\r\n</div>\r\n", // splitWidth: Integer // # of pixels between left & right part of button splitWidth: 2, // arrowWidth: Integer // width of segment holding down arrow arrowWidth: 5, _sizeMyselfHelper: function(/*Event*/ e){ var mb = dojo.html.getMarginBox(this.containerNode); this.height = mb.height; this.containerWidth = mb.width; var endWidth= this.height/3; if(this.disabled){ dojo.widget.wai.setAttr(this.domNode, "waiState", "disabled", true); this.domNode.removeAttribute("tabIndex"); } else { dojo.widget.wai.setAttr(this.domNode, "waiState", "disabled", false); this.domNode.setAttribute("tabIndex", "0"); } // left part this.leftImage.height = this.rightImage.height = this.centerImage.height = this.arrowBackgroundImage.height = this.height; this.leftImage.width = endWidth+1; this.centerImage.width = this.containerWidth; this.buttonNode.style.height = this.height + "px"; this.buttonNode.style.width = endWidth + this.containerWidth + "px"; this._setImage(this.disabled ? this.disabledImg : this.inactiveImg); // right part this.arrowBackgroundImage.width=this.arrowWidth; this.rightImage.width = endWidth+1; this.rightPart.style.height = this.height + "px"; this.rightPart.style.width = this.arrowWidth + endWidth + "px"; this._setImageR(this.disabled ? this.disabledImg : this.inactiveImg); // outer container this.domNode.style.height=this.height + "px"; var totalWidth = this.containerWidth+this.splitWidth+this.arrowWidth+2*endWidth; this.domNode.style.width= totalWidth + "px"; }, _setImage: function(prefix){ this.leftImage.src=dojo.uri.moduleUri("dojo.widget", prefix + "l.gif"); this.centerImage.src=dojo.uri.moduleUri("dojo.widget", prefix + "c.gif"); }, /*** functions on right part of button ***/ rightOver: function(/*Event*/ e){ // summary: // callback when mouse-over right part of button; // onMouseOver() is the callback for the left side of the button. if( this.disabled ){ return; } dojo.html.prependClass(this.rightPart, "dojoButtonHover"); this._setImageR(this.activeImg); }, rightDown: function(/*Event*/ e){ // summary: // callback when mouse-down right part of button; // onMouseDown() is the callback for the left side of the button. if( this.disabled ){ return; } dojo.html.prependClass(this.rightPart, "dojoButtonDepressed"); dojo.html.removeClass(this.rightPart, "dojoButtonHover"); this._setImageR(this.pressedImg); }, rightUp: function(/*Event*/ e){ // summary: // callback when mouse-up right part of button; // onMouseUp() is the callback for the left side of the button. if( this.disabled ){ return; } dojo.html.prependClass(this.rightPart, "dojoButtonHover"); dojo.html.removeClass(this.rightPart, "dojoButtonDepressed"); this._setImageR(this.activeImg); }, rightOut: function(/*Event*/ e){ // summary: // callback when moving the mouse off of the right part of button; // onMouseOut() is the callback for the left side of the button. if( this.disabled ){ return; } dojo.html.removeClass(this.rightPart, "dojoButtonHover"); dojo.html.removeClass(this.rightPart, "dojoButtonDepressed"); this._setImageR(this.inactiveImg); }, rightClick: function(/*Event*/ e){ // summary: // callback when clicking the right part of button; // onClick() is the callback for the left side of the button. if( this.disabled ){ return; } // focus may fail when tabIndex is not supported on div's // by the browser, or when the node is disabled try { this.domNode.focus(); } catch(e2) {}; this._toggleMenu(this.menuId); }, _setImageR: function(prefix){ this.arrowBackgroundImage.src=dojo.uri.moduleUri("dojo.widget", prefix + "c.gif"); this.rightImage.src=dojo.uri.moduleUri("dojo.widget", prefix + "r.gif"); }, /*** keyboard functions ***/ onKey: function(/*Event*/ e){ if (!e.key) { return; } var menu = dojo.widget.getWidgetById(this.menuId); if(e.key== e.KEY_ENTER || e.key == " "){ this.onMouseDown(e); this.buttonClick(e); dojo.lang.setTimeout(this, "onMouseUp", 75, e); dojo.event.browser.stopEvent(e); } else if (e.key == e.KEY_DOWN_ARROW && e.altKey){ this.rightDown(e); this.rightClick(e); dojo.lang.setTimeout(this, "rightUp", 75, e); dojo.event.browser.stopEvent(e); } else if(menu && menu.isShowingNow && e.key == e.KEY_DOWN_ARROW){ // disconnect onBlur when focus moves into menu dojo.event.disconnect(this.domNode, "onblur", this, "onBlur"); // allow event to propagate to menu } } }); dojo.provide("dojo.widget.ContentPane"); dojo.widget.defineWidget( "dojo.widget.ContentPane", dojo.widget.HtmlWidget, function(){ // summary: // A widget that can be used as a standalone widget // or as a baseclass for other widgets // Handles replacement of document fragment using either external uri or javascript/java // generated markup or DomNode content, instanciating widgets within content and runs scripts. // Dont confuse it with an iframe, it only needs document fragments. // It's useful as a child of LayoutContainer, SplitContainer, or TabContainer. // But note that those classes can contain any widget as a child. // scriptScope: Function // reference holder to the inline scripts container, if scriptSeparation is true // bindArgs: String[] // Send in extra args to the dojo.io.bind call // per widgetImpl variables this._styleNodes = []; this._onLoadStack = []; this._onUnloadStack = []; this._callOnUnload = false; this._ioBindObj; // Note: // dont change this value externally this.scriptScope; // undefined for now // loading option // example: // bindArgs="preventCache:false;" overrides cacheContent this.bindArgs = {}; }, { isContainer: true, // loading options // adjustPaths: Boolean // adjust relative paths in markup to fit this page adjustPaths: true, // href: String // The href of the content that displays now // Set this at construction if you want to load externally, // changing href after creation doesnt have any effect, see setUrl href: "", // extractContent Boolean: Extract visible content from inside of <body> .... </body> extractContent: true, // parseContent Boolean: Construct all widgets that is in content parseContent: true, // cacheContent Boolean: Cache content retreived externally cacheContent: true, // preload: Boolean // Force load of data even if pane is hidden. // Note: // In order to delay download you need to initially hide the node it constructs from preload: false, // refreshOnShow: Boolean // Refresh (re-download) content when pane goes from hidden to shown refreshOnShow: false, // handler: String||Function // Generate pane content from a java function // The name of the java proxy function handler: "", // executeScripts: Boolean // Run scripts within content, extractContent has NO effect on this. // Note: // if true scripts in content will be evaled after content is innerHTML'ed executeScripts: false, // scriptSeparation: Boolean // Run scripts in a separate scope, unique for each ContentPane scriptSeparation: true, // loadingMessage: String // Message that shows while downloading loadingMessage: "Loading...", // isLoaded: Boolean // Tells loading status isLoaded: false, postCreate: function(args, frag, parentComp){ if (this.handler!==""){ this.setHandler(this.handler); } if(this.isShowing() || this.preload){ this.loadContents(); } }, show: function(){ // if refreshOnShow is true, reload the contents every time; otherwise, load only the first time if(this.refreshOnShow){ this.refresh(); }else{ this.loadContents(); } dojo.widget.ContentPane.superclass.show.call(this); }, refresh: function(){ // summary: // Force a refresh (re-download) of content, be sure to turn of cache this.isLoaded=false; this.loadContents(); }, loadContents: function() { // summary: // Download if isLoaded is false, else ignore if ( this.isLoaded ){ return; } if ( dojo.lang.isFunction(this.handler)) { this._runHandler(); } else if ( this.href != "" ) { this._downloadExternalContent(this.href, this.cacheContent && !this.refreshOnShow); } }, setUrl: function(/*String||dojo.uri.Uri*/ url) { // summary: // Reset the (external defined) content of this pane and replace with new url // Note: // It delays the download until widget is shown if preload is false this.href = url; this.isLoaded = false; if ( this.preload || this.isShowing() ){ this.loadContents(); } }, abort: function(){ // summary // Aborts a inflight download of content var bind = this._ioBindObj; if(!bind || !bind.abort){ return; } bind.abort(); delete this._ioBindObj; }, _downloadExternalContent: function(url, useCache) { this.abort(); this._handleDefaults(this.loadingMessage, "onDownloadStart"); var self = this; this._ioBindObj = dojo.io.bind( this._cacheSetting({ url: url, mimetype: "text/html", handler: function(type, data, xhr){ delete self._ioBindObj; // makes sure abort doesnt clear cache if(type=="load"){ self.onDownloadEnd.call(self, url, data); }else{ // XHR isnt a normal JS object, IE doesnt have prototype on XHR so we cant extend it or shallowCopy it var e = { responseText: xhr.responseText, status: xhr.status, statusText: xhr.statusText, responseHeaders: xhr.getAllResponseHeaders(), text: "Error loading '" + url + "' (" + xhr.status + " "+ xhr.statusText + ")" }; self._handleDefaults.call(self, e, "onDownloadError"); self.onLoad(); } } }, useCache) ); }, _cacheSetting: function(bindObj, useCache){ for(var x in this.bindArgs){ if(dojo.lang.isUndefined(bindObj[x])){ bindObj[x] = this.bindArgs[x]; } } if(dojo.lang.isUndefined(bindObj.useCache)){ bindObj.useCache = useCache; } if(dojo.lang.isUndefined(bindObj.preventCache)){ bindObj.preventCache = !useCache; } if(dojo.lang.isUndefined(bindObj.mimetype)){ bindObj.mimetype = "text/html"; } return bindObj; }, onLoad: function(e){ // summary: // Event hook, is called after everything is loaded and widgetified this._runStack("_onLoadStack"); this.isLoaded=true; }, onUnLoad: function(e){ // summary: // Deprecated, use onUnload (lowercased load) dojo.deprecated(this.widgetType+".onUnLoad, use .onUnload (lowercased load)", 0.5); }, onUnload: function(e){ // summary: // Event hook, is called before old content is cleared this._runStack("_onUnloadStack"); delete this.scriptScope; // FIXME: remove for 0.5 along with onUnLoad if(this.onUnLoad !== dojo.widget.ContentPane.prototype.onUnLoad){ this.onUnLoad.apply(this, arguments); } }, _runStack: function(stName){ var st = this[stName]; var err = ""; var scope = this.scriptScope || window; for(var i = 0;i < st.length; i++){ try{ st[i].call(scope); }catch(e){ err += "\n"+st[i]+" failed: "+e.description; } } this[stName] = []; if(err.length){ var name = (stName== "_onLoadStack") ? "addOnLoad" : "addOnUnLoad"; this._handleDefaults(name+" failure\n "+err, "onExecError", "debug"); } }, addOnLoad: function(obj, func){ // summary // Stores function refs and calls them one by one in the order they came in // when load event occurs. // obj: Function||Object? // holder object // func: Function // function that will be called this._pushOnStack(this._onLoadStack, obj, func); }, addOnUnload: function(obj, func){ // summary // Stores function refs and calls them one by one in the order they came in // when unload event occurs. // obj: Function||Object // holder object // func: Function // function that will be called this._pushOnStack(this._onUnloadStack, obj, func); }, addOnUnLoad: function(){ // summary: // Deprecated use addOnUnload (lower cased load) dojo.deprecated(this.widgetType + ".addOnUnLoad, use addOnUnload instead. (lowercased Load)", 0.5); this.addOnUnload.apply(this, arguments); }, _pushOnStack: function(stack, obj, func){ if(typeof func == 'undefined') { stack.push(obj); }else{ stack.push(function(){ obj[func](); }); } }, destroy: function(){ // make sure we call onUnload this.onUnload(); dojo.widget.ContentPane.superclass.destroy.call(this); }, onExecError: function(/*Object*/e){ // summary: // called when content script eval error or Java error occurs, preventDefault-able // default is to debug not alert as in 0.3.1 }, onContentError: function(/*Object*/e){ // summary: // called on DOM faults, require fault etc in content, preventDefault-able // default is to display errormessage inside pane }, onDownloadError: function(/*Object*/e){ // summary: // called when download error occurs, preventDefault-able // default is to display errormessage inside pane }, onDownloadStart: function(/*Object*/e){ // summary: // called before download starts, preventDefault-able // default is to display loadingMessage inside pane // by changing e.text in your event handler you can change loading message }, // onDownloadEnd: function(url, data){ // summary: // called when download is finished // // url String: url that downloaded data // data String: the markup that was downloaded data = this.splitAndFixPaths(data, url); this.setContent(data); }, // useful if user wants to prevent default behaviour ie: _setContent("Error...") _handleDefaults: function(e, handler, messType){ if(!handler){ handler = "onContentError"; } if(dojo.lang.isString(e)){ e = {text: e}; } if(!e.text){ e.text = e.toString(); } e.toString = function(){ return this.text; }; if(typeof e.returnValue != "boolean"){ e.returnValue = true; } if(typeof e.preventDefault != "function"){ e.preventDefault = function(){ this.returnValue = false; }; } // call our handler this[handler](e); if(e.returnValue){ switch(messType){ case true: // fallthrough, old compat case "alert": alert(e.toString()); break; case "debug": dojo.debug(e.toString()); break; default: // makes sure scripts can clean up after themselves, before we setContent if(this._callOnUnload){ this.onUnload(); } // makes sure we dont try to call onUnLoad again on this event, // ie onUnLoad before 'Loading...' but not before clearing 'Loading...' this._callOnUnload = false; // we might end up in a endless recursion here if domNode cant append content if(arguments.callee._loopStop){ dojo.debug(e.toString()); }else{ arguments.callee._loopStop = true; this._setContent(e.toString()); } } } arguments.callee._loopStop = false; }, // pathfixes, require calls, css stuff and neccesary content clean splitAndFixPaths: function(s, url){ // summary: // adjusts all relative paths in (hopefully) all cases, images, remote scripts, links etc. // splits up content in different pieces, scripts, title, style, link and whats left becomes .xml // s String: The markup in string // url (String||dojo.uri.Uri?) url that pulled in markup var titles = [], scripts = [],tmp = [];// init vars var match = [], requires = [], attr = [], styles = []; var str = '', path = '', fix = '', tagFix = '', tag = '', origPath = ''; if(!url) { url = "./"; } // point to this page if not set if(s){ // make sure we dont run regexes on empty content /************** <title> ***********/ // khtml is picky about dom faults, you can't attach a <style> or <title> node as child of body // must go into head, so we need to cut out those tags var regex = /<title[^>]*>([\s\S]*?)<\/title>/i; while(match = regex.exec(s)){ titles.push(match[1]); s = s.substring(0, match.index) + s.substr(match.index + match[0].length); }; /************** adjust paths *****************/ if(this.adjustPaths){ // attributepaths one tag can have multiple paths example: // <input src="..." style="url(..)"/> or <a style="url(..)" href=".."> // strip out the tag and run fix on that. // this guarantees that we won't run replace on another tag's attribute + it was easier do var regexFindTag = /<[a-z][a-z0-9]*[^>]*\s(?:(?:src|href|style)=[^>])+[^>]*>/i; var regexFindAttr = /\s(src|href|style)=(['"]?)([\w()\[\]\/.,\\'"-:;#=&?\s@]+?)\2/i; // these are the supported protocols, all other is considered relative var regexProtocols = /^(?:[#]|(?:(?:https?|ftps?|file|javascript|mailto|news):))/; while(tag = regexFindTag.exec(s)){ str += s.substring(0, tag.index); s = s.substring((tag.index + tag[0].length), s.length); tag = tag[0]; // loop through attributes tagFix = ''; while(attr = regexFindAttr.exec(tag)){ path = ""; origPath = attr[3]; switch(attr[1].toLowerCase()){ case "src":// falltrough case "href": if(regexProtocols.exec(origPath)){ path = origPath; } else { path = (new dojo.uri.Uri(url, origPath).toString()); } break; case "style":// style path = dojo.html.fixPathsInCssText(origPath, url); break; default: path = origPath; } fix = " " + attr[1] + "=" + attr[2] + path + attr[2]; // slices up tag before next attribute check tagFix += tag.substring(0, attr.index) + fix; tag = tag.substring((attr.index + attr[0].length), tag.length); } str += tagFix + tag; //dojo.debug(tagFix + tag); } s = str+s; } /**************** cut out all <style> and <link rel="stylesheet" href=".."> **************/ regex = /(?:<(style)[^>]*>([\s\S]*?)<\/style>|<link ([^>]*rel=['"]?stylesheet['"]?[^>]*)>)/i; while(match = regex.exec(s)){ if(match[1] && match[1].toLowerCase() == "style"){ styles.push(dojo.html.fixPathsInCssText(match[2],url)); }else if(attr = match[3].match(/href=(['"]?)([^'">]*)\1/i)){ styles.push({path: attr[2]}); } s = s.substring(0, match.index) + s.substr(match.index + match[0].length); }; /***************** cut out all <script> tags, push them into scripts array ***************/ var regex = /<script([^>]*)>([\s\S]*?)<\/script>/i; var regexSrc = /src=(['"]?)([^"']*)\1/i; var regexDojoJs = /.*(\bdojo\b\.js(?:\.uncompressed\.js)?)$/; var regexInvalid = /(?:var )?\bdjConfig\b(?:[\s]*=[\s]*\{[^}]+\}|\.[\w]*[\s]*=[\s]*[^;\n]*)?;?|dojo\.hostenv\.writeIncludes\(\s*\);?/g; var regexRequires = /dojo\.(?:(?:require(?:After)?(?:If)?)|(?:widget\.(?:manager\.)?registerWidgetPackage)|(?:(?:hostenv\.)?setModulePrefix|registerModulePath)|defineNamespace)\((['"]).*?\1\)\s*;?/; while(match = regex.exec(s)){ if(this.executeScripts && match[1]){ if(attr = regexSrc.exec(match[1])){ // remove a dojo.js or dojo.js.uncompressed.js from remoteScripts // we declare all files named dojo.js as bad, regardless of path if(regexDojoJs.exec(attr[2])){ dojo.debug("Security note! inhibit:"+attr[2]+" from being loaded again."); }else{ scripts.push({path: attr[2]}); } } } if(match[2]){ // remove all invalid variables etc like djConfig and dojo.hostenv.writeIncludes() var sc = match[2].replace(regexInvalid, ""); if(!sc){ continue; } // cut out all dojo.require (...) calls, if we have execute // scripts false widgets dont get there require calls // takes out possible widgetpackage registration as well while(tmp = regexRequires.exec(sc)){ requires.push(tmp[0]); sc = sc.substring(0, tmp.index) + sc.substr(tmp.index + tmp[0].length); } if(this.executeScripts){ scripts.push(sc); } } s = s.substr(0, match.index) + s.substr(match.index + match[0].length); } /********* extract content *********/ if(this.extractContent){ match = s.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im); if(match) { s = match[1]; } } /*** replace scriptScope prefix in html Event handler * working order: find tags with scriptScope in a tag attribute * then replace all standalone scriptScope occurencies with reference to to this widget * valid onClick="scriptScope.func()" or onClick="scriptScope['func']();scriptScope.i++" * not valid onClick="var.scriptScope.ref" nor onClick="var['scriptScope'].ref" */ if(this.executeScripts && this.scriptSeparation){ var regex = /(<[a-zA-Z][a-zA-Z0-9]*\s[^>]*?\S=)((['"])[^>]*scriptScope[^>]*>)/; var regexAttr = /([\s'";:\(])scriptScope(.*)/; // we rely on that attribute begins ' or " str = ""; while(tag = regex.exec(s)){ tmp = ((tag[3]=="'") ? '"': "'");fix= ""; str += s.substring(0, tag.index) + tag[1]; while(attr = regexAttr.exec(tag[2])){ tag[2] = tag[2].substring(0, attr.index) + attr[1] + "dojo.widget.byId("+ tmp + this.widgetId + tmp + ").scriptScope" + attr[2]; } str += tag[2]; s = s.substr(tag.index + tag[0].length); } s = str + s; } } return {"xml": s, // Object "styles": styles, "titles": titles, "requires": requires, "scripts": scripts, "url": url}; }, _setContent: function(cont){ this.destroyChildren(); // remove old stylenodes from HEAD for(var i = 0; i < this._styleNodes.length; i++){ if(this._styleNodes[i] && this._styleNodes[i].parentNode){ this._styleNodes[i].parentNode.removeChild(this._styleNodes[i]); } } this._styleNodes = []; try{ var node = this.containerNode || this.domNode; while(node.firstChild){ dojo.html.destroyNode(node.firstChild); } if(typeof cont != "string"){ node.appendChild(cont); }else{ node.innerHTML = cont; } }catch(e){ e.text = "Couldn't load content:"+e.description; this._handleDefaults(e, "onContentError"); } }, setContent: function(data){ // summary: // Replaces old content with data content, include style classes from old content // data String||DomNode: new content, be it Document fragment or a DomNode chain // If data contains style tags, link rel=stylesheet it inserts those styles into DOM this.abort(); if(this._callOnUnload){ this.onUnload(); }// this tells a remote script clean up after itself this._callOnUnload = true; if(!data || dojo.html.isNode(data)){ // if we do a clean using setContent(""); or setContent(#node) bypass all parsing, extractContent etc this._setContent(data); this.onResized(); this.onLoad(); }else{ // need to run splitAndFixPaths? ie. manually setting content // adjustPaths is taken care of inside splitAndFixPaths if(typeof data.xml != "string"){ this.href = ""; // so we can refresh safely data = this.splitAndFixPaths(data); } this._setContent(data.xml); // insert styles from content (in same order they came in) for(var i = 0; i < data.styles.length; i++){ if(data.styles[i].path){ this._styleNodes.push(dojo.html.insertCssFile(data.styles[i].path, dojo.doc(), false, true)); }else{ this._styleNodes.push(dojo.html.insertCssText(data.styles[i])); } } if(this.parseContent){ for(var i = 0; i < data.requires.length; i++){ try{ eval(data.requires[i]); } catch(e){ e.text = "ContentPane: error in package loading calls, " + (e.description||e); this._handleDefaults(e, "onContentError", "debug"); } } } // need to allow async load, Xdomain uses it // is inline function because we cant send args to dojo.addOnLoad var _self = this; function asyncParse(){ if(_self.executeScripts){ _self._executeScripts(data.scripts); } if(_self.parseContent){ var node = _self.containerNode || _self.domNode; var parser = new dojo.xml.Parse(); var frag = parser.parseElement(node, null, true); // createSubComponents not createComponents because frag has already been created dojo.widget.getParser().createSubComponents(frag, _self); } _self.onResized(); _self.onLoad(); } // try as long as possible to make setContent sync call if(dojo.hostenv.isXDomain && data.requires.length){ dojo.addOnLoad(asyncParse); }else{ asyncParse(); } } }, setHandler: function(/*Function*/ handler) { // summary: // Generate pane content from given java function var fcn = dojo.lang.isFunction(handler) ? handler : window[handler]; if(!dojo.lang.isFunction(fcn)) { // FIXME: needs testing! somebody with java knowledge needs to try this this._handleDefaults("Unable to set handler, '" + handler + "' not a function.", "onExecError", true); return; } this.handler = function() { return fcn.apply(this, arguments); } }, _runHandler: function() { var ret = true; if(dojo.lang.isFunction(this.handler)) { this.handler(this, this.domNode); ret = false; } this.onLoad(); return ret; }, _executeScripts: function(scripts) { // loop through the scripts in the order they came in var self = this; var tmp = "", code = ""; for(var i = 0; i < scripts.length; i++){ if(scripts[i].path){ // remotescript dojo.io.bind(this._cacheSetting({ "url": scripts[i].path, "load": function(type, scriptStr){ dojo.lang.hitch(self, tmp = ";"+scriptStr); }, "error": function(type, error){ error.text = type + " downloading remote script"; self._handleDefaults.call(self, error, "onExecError", "debug"); }, "mimetype": "text/plain", "sync": true }, this.cacheContent)); code += tmp; }else{ code += scripts[i]; } } try{ if(this.scriptSeparation){ // initialize a new anonymous container for our script, dont make it part of this widgets scope chain // instead send in a variable that points to this widget, useful to connect events to onLoad, onUnload etc.. delete this.scriptScope; this.scriptScope = new (new Function('_container_', code+'; return this;'))(self); }else{ // exec in global, lose the _container_ feature var djg = dojo.global(); if(djg.execScript){ djg.execScript(code); }else{ var djd = dojo.doc(); var sc = djd.createElement("script"); sc.appendChild(djd.createTextNode(code)); (this.containerNode||this.domNode).appendChild(sc); } } }catch(e){ e.text = "Error running scripts from content:\n"+e.description; this._handleDefaults(e, "onExecError", "debug"); } } } ); dojo.provide("dojo.html.iframe"); // thanks burstlib! dojo.html.iframeContentWindow = function(/* HTMLIFrameElement */iframe_el) { // summary // returns the window reference of the passed iframe var win = dojo.html.getDocumentWindow(dojo.html.iframeContentDocument(iframe_el)) || // Moz. TODO: is this available when defaultView isn't? dojo.html.iframeContentDocument(iframe_el).__parent__ || (iframe_el.name && document.frames[iframe_el.name]) || null; return win; // Window } dojo.html.iframeContentDocument = function(/* HTMLIFrameElement */iframe_el){ // summary // returns a reference to the document object inside iframe_el var doc = iframe_el.contentDocument // W3 || ((iframe_el.contentWindow)&&(iframe_el.contentWindow.document)) // IE || ((iframe_el.name)&&(document.frames[iframe_el.name])&&(document.frames[iframe_el.name].document)) || null; return doc; // HTMLDocument } dojo.html.BackgroundIframe = function(/* HTMLElement */node) { // summary // For IE z-index schenanigans // Two possible uses: // 1. new dojo.html.BackgroundIframe(node) // Makes a background iframe as a child of node, that fills area (and position) of node // 2. new dojo.html.BackgroundIframe() // Attaches frame to dojo.body(). User must call size() to set size. if(dojo.render.html.ie55 || dojo.render.html.ie60) { var html="<iframe src='javascript:false'" + " style='position: absolute; left: 0px; top: 0px; width: 100%; height: 100%;" + "z-index: -1; filter:Alpha(Opacity=\"0\");' " + ">"; this.iframe = dojo.doc().createElement(html); this.iframe.tabIndex = -1; // Magic to prevent iframe from getting focus on tab keypress - as style didnt work. if(node){ node.appendChild(this.iframe); this.domNode=node; }else{ dojo.body().appendChild(this.iframe); this.iframe.style.display="none"; } } } dojo.lang.extend(dojo.html.BackgroundIframe, { iframe: null, onResized: function(){ // summary // Resize event handler. // TODO: this function shouldn't be necessary but setting width=height=100% doesn't work! if(this.iframe && this.domNode && this.domNode.parentNode){ // No parentElement if onResized() timeout event occurs on a removed domnode var outer = dojo.html.getMarginBox(this.domNode); if (outer.width == 0 || outer.height == 0 ){ dojo.lang.setTimeout(this, this.onResized, 100); return; } this.iframe.style.width = outer.width + "px"; this.iframe.style.height = outer.height + "px"; } }, size: function(/* HTMLElement */node) { // summary: // Call this function if the iframe is connected to dojo.body() // rather than the node being shadowed // (TODO: erase) if(!this.iframe){ return; } var coords = dojo.html.toCoordinateObject(node, true, dojo.html.boxSizing.BORDER_BOX); with(this.iframe.style){ width = coords.width + "px"; height = coords.height + "px"; left = coords.left + "px"; top = coords.top + "px"; } }, setZIndex: function(/* HTMLElement */node){ // summary // Sets the z-index of the background iframe. if(!this.iframe){ return; } if(dojo.dom.isNode(node)){ this.iframe.style.zIndex = dojo.html.getStyle(node, "z-index") - 1; }else if(!isNaN(node)){ this.iframe.style.zIndex = node; } }, show: function(){ // summary: // show the iframe if(this.iframe){ this.iframe.style.display = "block"; } }, hide: function(){ // summary: // hide the iframe if(this.iframe){ this.iframe.style.display = "none"; } }, remove: function(){ // summary: // remove the iframe if(this.iframe){ dojo.html.removeNode(this.iframe, true); delete this.iframe; this.iframe=null; } } }); dojo.provide("dojo.widget.Dialog"); dojo.declare( "dojo.widget.ModalDialogBase", null, { // summary // Mixin for widgets implementing a modal dialog isContainer: true, // focusElement: String // provide a focusable element or element id if you need to // work around FF's tendency to send focus into outer space on hide focusElement: "", // bgColor: String // color of viewport when displaying a dialog bgColor: "black", // bgOpacity: Number // opacity (0~1) of viewport color (see bgColor attribute) bgOpacity: 0.4, // followScroll: Boolean // if true, readjusts the dialog (and dialog background) when the user moves the scrollbar followScroll: true, // closeOnBackgroundClick: Boolean // clicking anywhere on the background will close the dialog closeOnBackgroundClick: false, trapTabs: function(/*Event*/ e){ // summary // callback on focus if(e.target == this.tabStartOuter) { if(this._fromTrap) { this.tabStart.focus(); this._fromTrap = false; } else { this._fromTrap = true; this.tabEnd.focus(); } } else if (e.target == this.tabStart) { if(this._fromTrap) { this._fromTrap = false; } else { this._fromTrap = true; this.tabEnd.focus(); } } else if(e.target == this.tabEndOuter) { if(this._fromTrap) { this.tabEnd.focus(); this._fromTrap = false; } else { this._fromTrap = true; this.tabStart.focus(); } } else if(e.target == this.tabEnd) { if(this._fromTrap) { this._fromTrap = false; } else { this._fromTrap = true; this.tabStart.focus(); } } }, clearTrap: function(/*Event*/ e) { // summary // callback on blur var _this = this; setTimeout(function() { _this._fromTrap = false; }, 100); }, postCreate: function() { // summary // if the target mixin class already defined postCreate, // dojo.widget.ModalDialogBase.prototype.postCreate.call(this) // should be called in its postCreate() with(this.domNode.style){ position = "absolute"; zIndex = 999; display = "none"; overflow = "visible"; } var b = dojo.body(); b.appendChild(this.domNode); // make background (which sits behind the dialog but above the normal text) this.bg = document.createElement("div"); this.bg.className = "dialogUnderlay"; with(this.bg.style){ position = "absolute"; left = top = "0px"; zIndex = 998; display = "none"; } b.appendChild(this.bg); this.setBackgroundColor(this.bgColor); this.bgIframe = new dojo.html.BackgroundIframe(); if(this.bgIframe.iframe){ with(this.bgIframe.iframe.style){ position = "absolute"; left = top = "0px"; zIndex = 90; display = "none"; } } if(this.closeOnBackgroundClick){ dojo.event.kwConnect({srcObj: this.bg, srcFunc: "onclick", adviceObj: this, adviceFunc: "onBackgroundClick", once: true}); } }, uninitialize: function(){ this.bgIframe.remove(); dojo.html.removeNode(this.bg, true); }, setBackgroundColor: function(/*String*/ color) { // summary // changes background color specified by "bgColor" parameter // usage: // setBackgroundColor("black"); // setBackgroundColor(0xff, 0xff, 0xff); if(arguments.length >= 3) { color = new dojo.gfx.color.Color(arguments[0], arguments[1], arguments[2]); } else { color = new dojo.gfx.color.Color(color); } this.bg.style.backgroundColor = color.toString(); return this.bgColor = color; // String: the color }, setBackgroundOpacity: function(/*Number*/ op) { // summary // changes background opacity set by "bgOpacity" parameter if(arguments.length == 0) { op = this.bgOpacity; } dojo.html.setOpacity(this.bg, op); try { this.bgOpacity = dojo.html.getOpacity(this.bg); } catch (e) { this.bgOpacity = op; } return this.bgOpacity; // Number: the opacity }, _sizeBackground: function() { if(this.bgOpacity > 0) { var viewport = dojo.html.getViewport(); var h = viewport.height; var w = viewport.width; with(this.bg.style){ width = w + "px"; height = h + "px"; } var scroll_offset = dojo.html.getScroll().offset; this.bg.style.top = scroll_offset.y + "px"; this.bg.style.left = scroll_offset.x + "px"; // process twice since the scroll bar may have been removed // by the previous resizing var viewport = dojo.html.getViewport(); if (viewport.width != w) { this.bg.style.width = viewport.width + "px"; } if (viewport.height != h) { this.bg.style.height = viewport.height + "px"; } } this.bgIframe.size(this.bg); }, _showBackground: function() { if(this.bgOpacity > 0) { this.bg.style.display = "block"; } if(this.bgIframe.iframe){ this.bgIframe.iframe.style.display = "block"; } }, placeModalDialog: function() { // summary: position modal dialog in center of screen var scroll_offset = dojo.html.getScroll().offset; var viewport_size = dojo.html.getViewport(); // find the size of the dialog (dialog needs to be showing to get the size) var mb; if(this.isShowing()){ mb = dojo.html.getMarginBox(this.domNode); }else{ dojo.html.setVisibility(this.domNode, false); dojo.html.show(this.domNode); mb = dojo.html.getMarginBox(this.domNode); dojo.html.hide(this.domNode); dojo.html.setVisibility(this.domNode, true); } var x = scroll_offset.x + (viewport_size.width - mb.width)/2; var y = scroll_offset.y + (viewport_size.height - mb.height)/2; with(this.domNode.style){ left = x + "px"; top = y + "px"; } }, _onKey: function(/*Event*/ evt){ if (evt.key){ // see if the key is for the dialog var node = evt.target; while (node != null){ if (node == this.domNode){ return; // yes, so just let it go } node = node.parentNode; } // this key is for the disabled document window if (evt.key != evt.KEY_TAB){ // allow tabbing into the dialog for a11y dojo.event.browser.stopEvent(evt); // opera won't tab to a div }else if (!dojo.render.html.opera){ try { this.tabStart.focus(); } catch(e){} } } }, showModalDialog: function() { // summary // call this function in show() of subclass before calling superclass.show() if (this.followScroll && !this._scrollConnected){ this._scrollConnected = true; dojo.event.connect(window, "onscroll", this, "_onScroll"); } dojo.event.connect(document.documentElement, "onkey", this, "_onKey"); this.placeModalDialog(); this.setBackgroundOpacity(); this._sizeBackground(); this._showBackground(); this._fromTrap = true; // set timeout to allow the browser to render dialog setTimeout(dojo.lang.hitch(this, function(){ try{ this.tabStart.focus(); }catch(e){} }), 50); }, hideModalDialog: function(){ // summary // call this function in hide() of subclass // workaround for FF focus going into outer space if (this.focusElement) { dojo.byId(this.focusElement).focus(); dojo.byId(this.focusElement).blur(); } this.bg.style.display = "none"; this.bg.style.width = this.bg.style.height = "1px"; if(this.bgIframe.iframe){ this.bgIframe.iframe.style.display = "none"; } dojo.event.disconnect(document.documentElement, "onkey", this, "_onKey"); if (this._scrollConnected){ this._scrollConnected = false; dojo.event.disconnect(window, "onscroll", this, "_onScroll"); } }, _onScroll: function(){ var scroll_offset = dojo.html.getScroll().offset; this.bg.style.top = scroll_offset.y + "px"; this.bg.style.left = scroll_offset.x + "px"; this.placeModalDialog(); }, checkSize: function() { if(this.isShowing()){ this._sizeBackground(); this.placeModalDialog(); this.onResized(); } }, onBackgroundClick: function(){ // summary // Callback on background click. // Clicking anywhere on the background will close the dialog, but only // if the dialog doesn't have an explicit close button, and only if // the dialog doesn't have a blockDuration. if(this.lifetime - this.timeRemaining >= this.blockDuration){ return; } this.hide(); } }); dojo.widget.defineWidget( "dojo.widget.Dialog", [dojo.widget.ContentPane, dojo.widget.ModalDialogBase], { // summary // Pops up a modal dialog window, blocking access to the screen and also graying out the screen // Dialog is extended from ContentPane so it supports all the same parameters (href, etc.) templateString:"<div id=\"${this.widgetId}\" class=\"dojoDialog\" dojoattachpoint=\"wrapper\">\r\n\t<span dojoattachpoint=\"tabStartOuter\" dojoonfocus=\"trapTabs\" dojoonblur=\"clearTrap\"\ttabindex=\"0\"></span>\r\n\t<span dojoattachpoint=\"tabStart\" dojoonfocus=\"trapTabs\" dojoonblur=\"clearTrap\" tabindex=\"0\"></span>\r\n\t<div dojoattachpoint=\"containerNode\" style=\"position: relative; z-index: 2;\"></div>\r\n\t<span dojoattachpoint=\"tabEnd\" dojoonfocus=\"trapTabs\" dojoonblur=\"clearTrap\" tabindex=\"0\"></span>\r\n\t<span dojoattachpoint=\"tabEndOuter\" dojoonfocus=\"trapTabs\" dojoonblur=\"clearTrap\" tabindex=\"0\"></span>\r\n</div>\r\n", // blockDuration: Integer // number of seconds for which the user cannot dismiss the dialog blockDuration: 0, // lifetime: Integer // if set, this controls the number of seconds the dialog will be displayed before automatically disappearing lifetime: 0, // closeNode: String // Id of button or other dom node to click to close this dialog closeNode: "", postMixInProperties: function(){ dojo.widget.Dialog.superclass.postMixInProperties.apply(this, arguments); if(this.closeNode){ this.setCloseControl(this.closeNode); } }, postCreate: function(){ dojo.widget.Dialog.superclass.postCreate.apply(this, arguments); dojo.widget.ModalDialogBase.prototype.postCreate.apply(this, arguments); }, show: function() { if(this.lifetime){ this.timeRemaining = this.lifetime; if(this.timerNode){ this.timerNode.innerHTML = Math.ceil(this.timeRemaining/1000); } if(this.blockDuration && this.closeNode){ if(this.lifetime > this.blockDuration){ this.closeNode.style.visibility = "hidden"; }else{ this.closeNode.style.display = "none"; } } if (this.timer) { clearInterval(this.timer); } this.timer = setInterval(dojo.lang.hitch(this, "_onTick"), 100); } this.showModalDialog(); dojo.widget.Dialog.superclass.show.call(this); }, onLoad: function(){ // when href is specified we need to reposition // the dialog after the data is loaded this.placeModalDialog(); dojo.widget.Dialog.superclass.onLoad.call(this); }, fillInTemplate: function(){ // dojo.event.connect(this.domNode, "onclick", this, "killEvent"); }, hide: function(){ this.hideModalDialog(); dojo.widget.Dialog.superclass.hide.call(this); if(this.timer){ clearInterval(this.timer); } }, setTimerNode: function(node){ // summary // specify into which node to write the remaining # of seconds // TODO: make this a parameter too this.timerNode = node; }, setCloseControl: function(/*String|DomNode*/ node) { // summary // Specify which node is the close button for this dialog. // If no close node is specified then clicking anywhere on the screen will close the dialog. this.closeNode = dojo.byId(node); dojo.event.connect(this.closeNode, "onclick", this, "hide"); }, setShowControl: function(/*String|DomNode*/ node) { // summary // when specified node is clicked, show this dialog // TODO: make this a parameter too node = dojo.byId(node); dojo.event.connect(node, "onclick", this, "show"); }, _onTick: function(){ // summary // callback every second that the timer clicks if(this.timer){ this.timeRemaining -= 100; if(this.lifetime - this.timeRemaining >= this.blockDuration){ // TODO: this block of code is executing over and over again, rather than just once if(this.closeNode){ this.closeNode.style.visibility = "visible"; } } if(!this.timeRemaining){ clearInterval(this.timer); this.hide(); }else if(this.timerNode){ this.timerNode.innerHTML = Math.ceil(this.timeRemaining/1000); } } } } ); dojo.provide("dojo.widget.TreeWithNode"); dojo.declare( "dojo.widget.TreeWithNode", null, function(){ }, { /* * dynamic loading-related stuff. * When an empty folder node appears, it is "UNCHECKED" first, * then after Rpc call it becomes LOADING and, finally LOADED * * tree may be dynamically loaded also */ loadStates: { UNCHECKED: "UNCHECKED", LOADING: "LOADING", LOADED: "LOADED" }, state: "UNCHECKED", // after creation will change to loadStates: "loaded/loading/unchecked" //RpcUrl: "", // user can override rpc url for specific nodes objectId: "", // the widget represents an object // I need this to parse children isContainer: true, lockLevel: 0, // lock ++ unlock --, so nested locking works fine lock: function() { this.lockLevel++; }, unlock: function() { if (!this.lockLevel) { //dojo.debug((new Error()).stack); dojo.raise(this.widgetType+" unlock: not locked"); } this.lockLevel--; }, expandLevel: 0, // expand to level automatically loadLevel: 0, // load to level automatically hasLock: function() { return this.lockLevel>0; }, isLocked: function() { var node = this; while (true) { if (node.lockLevel) { return true; } if (!node.parent || node.isTree) { break; } node = node.parent; } return false; }, flushLock: function() { this.lockLevel = 0; //this.unMarkLoading(); }, actionIsDisabled: function(action) { var disabled = false; if (dojo.lang.inArray(this.actionsDisabled, action)) { disabled = true; } //dojo.debug("Check "+this+" "+disabled) if (this.isTreeNode) { if (!this.tree.allowAddChildToLeaf && action == this.actions.ADDCHILD && !this.isFolder) { disabled = true; } } return disabled; }, actionIsDisabledNow: function(action) { return this.actionIsDisabled(action) || this.isLocked(); }, /** * childrenArray is array of Widgets or array of Objects * widgets may be both attached and detached * * Use Cases * 1) lots of widgets are packed and passed in. * - widgets are created * - widgets have no parent (detached or not attached yet) * * 2) array of widgets and data objects passed in with flag makeWidgetsFromChildren * - some widgets are not created * - all objects have no parent * * 3) expand is called with makeWidgetsFromChildren=true * - some objects need to be turned into widgets * - some widgets have parent (e.g markup), some widgets and objects do not * * Will folderize a node as side-effect. */ setChildren: function(childrenArray) { //dojo.profile.start("setChildren "+this); //dojo.debug("setChildren in "+this); if (this.isTreeNode && !this.isFolder) { //dojo.debug("folder parent "+parent+ " isfolder "+parent.isFolder); this.setFolder(); } else if (this.isTreeNode) { this.state = this.loadStates.LOADED; } var hadChildren = this.children.length > 0; if (hadChildren && childrenArray){ // perf: most of time setChildren used for empty nodes, so save function call this.destroyChildren() } if (childrenArray) { this.children = childrenArray; } var hasChildren = this.children.length > 0; if (this.isTreeNode && hasChildren != hadChildren) { // call only when hasChildren state changes this.viewSetHasChildren(); } for(var i=0; i<this.children.length; i++) { var child = this.children[i]; //dojo.profile.start("setChildren - create "+this); if (!(child instanceof dojo.widget.Widget)) { child = this.children[i] = this.tree.createNode(child); var childWidgetCreated = true; //dojo.debugShallow(child) //dojo.debug("setChildren creates node "+child); } else { var childWidgetCreated = false; } //dojo.profile.end("setChildren - create "+this); //dojo.profile.start("setChildren - attach "+this); if (!child.parent) { // detached child //dojo.debug("detached child "+child); child.parent = this; //dojo.profile.start("setChildren - updateTree "+this); if (this.tree !== child.tree) { child.updateTree(this.tree); } //dojo.profile.end("setChildren - updateTree "+this); //dojo.debug("Add layout for "+child); child.viewAddLayout(); this.containerNode.appendChild(child.domNode); var message = { child: child, index: i, parent: this, childWidgetCreated: childWidgetCreated } delete dojo.widget.manager.topWidgets[child.widgetId]; //dojo.profile.start("setChildren - event "+this); //dojo.debug("publish "+this.tree.eventNames.afterAddChild) dojo.event.topic.publish(this.tree.eventNames.afterAddChild, message); //dojo.profile.end("setChildren - event "+this); } if (this.tree.eagerWidgetInstantiation) { dojo.lang.forEach(this.children, function(child) { child.setChildren(); }); } //dojo.profile.end("setChildren - attach "+this); } //dojo.profile.end("setChildren "+this); }, doAddChild: function(child, index) { return this.addChild(child, index, true); }, addChild: function(child, index, dontPublishEvent) { if (dojo.lang.isUndefined(index)) { index = this.children.length; } //dojo.debug("doAddChild "+index+" called for "+this+" child "+child+" existing children "+(this.children.length ? this.children : "<no children>")); if (!child.isTreeNode){ dojo.raise("You can only add TreeNode widgets to a "+this.widgetType+" widget!"); return; } this.children.splice(index, 0, child); child.parent = this; child.addedTo(this, index, dontPublishEvent); // taken from DomWidget.registerChild // delete from widget list that are notified on resize etc (no parent) delete dojo.widget.manager.topWidgets[child.widgetId]; }, /** * does not inform children about resize (skips onShow), * because on large trees that's slow */ onShow: function() { this.animationInProgress=false; }, onHide: function() { this.animationInProgress=false; } }); dojo.provide("dojo.widget.TreeNodeV3"); dojo.widget.defineWidget( "dojo.widget.TreeNodeV3", [dojo.widget.HtmlWidget, dojo.widget.TreeWithNode], function() { this.actionsDisabled = []; this.object = {}; }, { tryLazyInit: true, /* * Basic actions one can perform on nodes and, some(addchild) on trees */ actions: { MOVE: "MOVE", DETACH: "DETACH", EDIT: "EDIT", ADDCHILD: "ADDCHILD", SELECT: "SELECT" }, labelClass: "", contentClass: "", expandNode: null, labelNode: null, /** * can't call it nodeType cause of IE problems */ nodeDocType: "", selected: false, getnodeDocType: function() { return this.nodeDocType; }, cloneProperties: ["actionsDisabled","tryLazyInit","nodeDocType","objectId","object", "title","isFolder","isExpanded","state"], /** * copy cloneProperties with recursion into them * contains "copy constructor" */ clone: function(deep) { var ret = new this.constructor(); //dojo.debug("start cloning props "+this); for(var i=0; i<this.cloneProperties.length; i++) { var prop = this.cloneProperties[i]; //dojo.debug("cloning "+prop+ ":" +this[prop]); ret[prop] = dojo.lang.shallowCopy(this[prop], true); } if (this.tree.unsetFolderOnEmpty && !deep && this.isFolder) { ret.isFolder = false; } //dojo.debug("cloned props "+this); ret.toggleObj = this.toggleObj; dojo.widget.manager.add(ret); ret.tree = this.tree; ret.buildRendering({},{}); ret.initialize({},{}); if (deep && this.children.length) { //dojo.debug("deeper copy start"); for(var i=0; i<this.children.length; i++) { var child = this.children[i]; //dojo.debug("copy child "+child); if (child.clone) { ret.children.push(child.clone(deep)); } else { ret.children.push(dojo.lang.shallowCopy(child, deep)); } } //dojo.debug("deeper copy end"); ret.setChildren(); } return ret; }, markProcessing: function() { this.markProcessingSavedClass = dojo.html.getClass(this.expandNode); dojo.html.setClass(this.expandNode, this.tree.classPrefix+'ExpandLoading'); }, unmarkProcessing: function() { dojo.html.setClass(this.expandNode, this.markProcessingSavedClass); }, /** * get information from args & parent, then build rendering */ buildRendering: function(args, fragment, parent) { //dojo.debug("Build for "+args.toSource()); if (args.tree) { this.tree = dojo.lang.isString(args.tree) ? dojo.widget.manager.getWidgetById(args.tree) : args.tree; } else if (parent && parent.tree) { this.tree = parent.tree; } if (!this.tree) { dojo.raise("Can't evaluate tree from arguments or parent"); } //dojo.profile.start("buildRendering - cloneNode"); this.domNode = this.tree.nodeTemplate.cloneNode(true); this.expandNode = this.domNode.firstChild; this.contentNode = this.domNode.childNodes[1]; this.labelNode = this.contentNode.firstChild; if (this.labelClass) { dojo.html.addClass(this.labelNode, this.labelClass); } if (this.contentClass) { dojo.html.addClass(this.contentNode, this.contentClass); } //dojo.profile.end("buildRendering - cloneNode"); this.domNode.widgetId = this.widgetId; //dojo.profile.start("buildRendering - innerHTML"); this.labelNode.innerHTML = this.title; //dojo.profile.end("buildRendering - innerHTML"); }, isTreeNode: true, object: {}, title: "", isFolder: null, // set by widget depending on children/args contentNode: null, // the item label expandClass: "", isExpanded: false, containerNode: null, getInfo: function() { // No title here (title may be widget) var info = { widgetId: this.widgetId, objectId: this.objectId, index: this.getParentIndex() } return info; }, setFolder: function() { //dojo.debug("SetFolder in "+this); this.isFolder = true; this.viewSetExpand(); if (!this.containerNode) { // maybe this node was unfolderized and still has container this.viewAddContainer(); // all folders have container. } //dojo.debug("publish "+this.tree.eventNames.setFolder); dojo.event.topic.publish(this.tree.eventNames.afterSetFolder, { source: this }); }, initialize: function(args, frag, parent) { //dojo.profile.start("initialize"); /** * first we populate current widget from args, * then use its data to initialize * args may be empty, all data inside widget for copy constructor */ if (args.isFolder) { this.isFolder = true; } if (this.children.length || this.isFolder) { //dojo.debug("children found"); //dojo.debug(this.children); //dojo.debug("isFolder "+args.isFolder); // viewSetExpand for Folder is set here also this.setFolder(); } else { // set expandicon for leaf this.viewSetExpand(); } for(var i=0; i<this.actionsDisabled.length;i++) { this.actionsDisabled[i] = this.actionsDisabled[i].toUpperCase(); } //dojo.debug("publish "+this.tree.eventNames.changeTree); dojo.event.topic.publish(this.tree.eventNames.afterChangeTree, {oldTree:null, newTree:this.tree, node:this} ); //dojo.profile.end("initialize"); //dojo.debug("initialize out "+this); //dojo.debug(this+" parent "+parent); }, unsetFolder: function() { this.isFolder = false; this.viewSetExpand(); dojo.event.topic.publish(this.tree.eventNames.afterUnsetFolder, { source: this }); }, insertNode: function(parent, index) { if (!index) index = 0; //dojo.debug("insertNode "+this+" parent "+parent+" before "+index); if (index==0) { dojo.html.prependChild(this.domNode, parent.containerNode); } else { dojo.html.insertAfter(this.domNode, parent.children[index-1].domNode); } }, updateTree: function(newTree) { if (this.tree === newTree) { return; } var oldTree = this.tree; dojo.lang.forEach(this.getDescendants(), function(elem) { elem.tree = newTree; }); /** * UNTESTED * changes class prefix for all domnodes when moving between trees */ if (oldTree.classPrefix != newTree.classPrefix) { var stack = [this.domNode] var elem; var reg = new RegExp("(^|\\s)"+oldTree.classPrefix, "g"); while (elem = stack.pop()) { for(var i=0; i<elem.childNodes.length; i++) { var childNode = elem.childNodes[i] if (childNode.nodeDocType != 1) continue; // change prefix for classes dojo.html.setClass(childNode, dojo.html.getClass(childNode).replace(reg, '$1'+newTree.classPrefix)); stack.push(childNode); } } } var message = {oldTree:oldTree, newTree:newTree, node:this} dojo.event.topic.publish(this.tree.eventNames.afterChangeTree, message ); dojo.event.topic.publish(newTree.eventNames.afterChangeTree, message ); }, /** * called every time the widget is added with createWidget or created wia markup * from addChild -> registerChild or from postInitialize->registerChild * not called in batch procession * HTML & widget.createWidget only * Layout MUST be removed when node is detached * */ addedTo: function(parent, index, dontPublishEvent) { //dojo.profile.start("addedTo"); //dojo.debug(this + " addedTo "+parent+" index "+index); //dojo.debug(parent.children); //dojo.debug(parent.containerNode.innerHTML); //dojo.debug((new Error()).stack); if (this.tree !== parent.tree) { this.updateTree(parent.tree); } if (parent.isTreeNode) { if (!parent.isFolder) { //dojo.debug("folderize parent "+parent); parent.setFolder(); parent.state = parent.loadStates.LOADED; } } var siblingsCount = parent.children.length; // setFolder works BEFORE insertNode this.insertNode(parent, index); this.viewAddLayout(); //dojo.debug("siblings "+parent.children); if (siblingsCount > 1) { if (index == 0 && parent.children[1] instanceof dojo.widget.Widget) { parent.children[1].viewUpdateLayout(); } if (index == siblingsCount-1 && parent.children[siblingsCount-2] instanceof dojo.widget.Widget) { parent.children[siblingsCount-2].viewUpdateLayout(); } } else if (parent.isTreeNode) { // added as the first child //dojo.debug("added as first"); parent.viewSetHasChildren(); } if (!dontPublishEvent) { var message = { child: this, index: index, parent: parent } dojo.event.topic.publish(this.tree.eventNames.afterAddChild, message); } //dojo.profile.end("addedTo"); }, /** * Fast program-only hacky creation of widget * */ createSimple: function(args, parent) { // I pass no args and ignore default controller //dojo.profile.start(this.widgetType+" createSimple"); //dojo.profile.start(this.widgetType+" createSimple constructor"); if (args.tree) { var tree = args.tree; } else if (parent) { var tree = parent.tree; } else { dojo.raise("createSimple: can't evaluate tree"); } tree = dojo.widget.byId(tree); //dojo.debug(tree); var treeNode = new tree.defaultChildWidget(); //dojo.profile.end(this.widgetType+" createSimple constructor"); //dojo.profile.start(this.widgetType+" createSimple mixin"); for(var x in args){ // fastMixIn treeNode[x] = args[x]; } //dojo.profile.end(this.widgetType+" createSimple mixin"); // HtmlWidget.postMixIn treeNode.toggleObj = dojo.lfx.toggle[treeNode.toggle.toLowerCase()] || dojo.lfx.toggle.plain; //dojo.profile.start(this.widgetType + " manager"); dojo.widget.manager.add(treeNode); //dojo.profile.end(this.widgetType + " manager"); //dojo.profile.start(this.widgetType + " buildRendering"); treeNode.buildRendering(args, {}, parent); //dojo.profile.end(this.widgetType + " buildRendering"); treeNode.initialize(args, {}, parent); //dojo.profile.end(this.widgetType+"createSimple"); if (treeNode.parent) { delete dojo.widget.manager.topWidgets[treeNode.widgetId]; } return treeNode; }, // can override e.g for case of div with +- text inside viewUpdateLayout: function() { //dojo.profile.start("viewUpdateLayout"); //dojo.debug("UpdateLayout in "+this); this.viewRemoveLayout(); this.viewAddLayout(); //dojo.profile.end("viewUpdateLayout"); }, viewAddContainer: function() { // make controller only if children exist this.containerNode = this.tree.containerNodeTemplate.cloneNode(true); this.domNode.appendChild(this.containerNode); }, /* viewRemoveContainer: function() { // make controller only if children exist this.domNode.removeChild(this.containerNode); this.containerNode = null; }, */ viewAddLayout: function() { //dojo.profile.start("viewAddLayout"); //dojo.debug("viewAddLayout in "+this); if (this.parent["isTree"]) { //dojo.debug("Parent isTree => add isTreeRoot"); // use setClass, not addClass for speed dojo.html.setClass(this.domNode, dojo.html.getClass(this.domNode) + ' '+this.tree.classPrefix+'IsRoot') } //dojo.debug(this.parent.children.length); //dojo.debug(this.parent.children[this.parent.children.length-1]); if (this.isLastChild()) { //dojo.debug("Checked last node for "+this); //dojo.debug("Parent last is "+this.parent.children[this.parent.children.length-1]); //dojo.debug("last node => add isTreeLast for "+this); dojo.html.setClass(this.domNode, dojo.html.getClass(this.domNode) + ' '+this.tree.classPrefix+'IsLast') } //dojo.profile.end("viewAddLayout"); //dojo.debug("viewAddLayout out"); }, viewRemoveLayout: function() { //dojo.debug("viewRemoveLayout in "+this); //dojo.profile.start("viewRemoveLayout"); //dojo.debug((new Error()).stack); dojo.html.removeClass(this.domNode, this.tree.classPrefix+"IsRoot"); dojo.html.removeClass(this.domNode, this.tree.classPrefix+"IsLast"); //dojo.profile.end("viewRemoveLayout"); }, viewGetExpandClass: function() { if (this.isFolder) { return this.isExpanded ? "ExpandOpen" : "ExpandClosed"; } else { return "ExpandLeaf"; } }, viewSetExpand: function() { //dojo.profile.start("viewSetExpand"); //dojo.debug("viewSetExpand in "+this); var expand = this.tree.classPrefix+this.viewGetExpandClass(); var reg = new RegExp("(^|\\s)"+this.tree.classPrefix+"Expand\\w+",'g'); dojo.html.setClass(this.domNode, dojo.html.getClass(this.domNode).replace(reg,'') + ' '+expand); //dojo.debug(dojo.html.getClass(this.domNode)) //dojo.profile.end("viewSetExpand"); this.viewSetHasChildrenAndExpand(); }, viewGetChildrenClass: function() { return 'Children'+(this.children.length ? 'Yes' : 'No'); }, viewSetHasChildren: function() { //dojo.debug(this+' '+this.children.length) var clazz = this.tree.classPrefix+this.viewGetChildrenClass(); var reg = new RegExp("(^|\\s)"+this.tree.classPrefix+"Children\\w+",'g'); dojo.html.setClass(this.domNode, dojo.html.getClass(this.domNode).replace(reg,'') + ' '+clazz); this.viewSetHasChildrenAndExpand(); }, /** * set TreeStateChildrenYes-ExpandClosed pair * needed for IE, because IE reads only last class from .TreeChildrenYes.TreeExpandClosed pair */ viewSetHasChildrenAndExpand: function() { var clazz = this.tree.classPrefix+'State'+this.viewGetChildrenClass()+'-'+this.viewGetExpandClass(); var reg = new RegExp("(^|\\s)"+this.tree.classPrefix+"State[\\w-]+",'g'); dojo.html.setClass(this.domNode, dojo.html.getClass(this.domNode).replace(reg,'') + ' '+clazz); }, viewUnfocus: function() { dojo.html.removeClass(this.labelNode, this.tree.classPrefix+"LabelFocused"); }, viewFocus: function() { dojo.html.addClass(this.labelNode, this.tree.classPrefix+"LabelFocused"); }, viewEmphasize: function() { dojo.html.clearSelection(this.labelNode); dojo.html.addClass(this.labelNode, this.tree.classPrefix+'NodeEmphasized'); }, viewUnemphasize: function() { dojo.html.removeClass(this.labelNode, this.tree.classPrefix+'NodeEmphasized'); }, // ================================ detach from parent =================================== detach: function() { if (!this.parent) return; var parent = this.parent; var index = this.getParentIndex(); this.doDetach.apply(this, arguments); dojo.event.topic.publish(this.tree.eventNames.afterDetach, { child: this, parent: parent, index:index } ); }, /* node does not leave tree */ doDetach: function() { //dojo.debug("doDetach in "+this+" parent "+this.parent+" class "+dojo.html.getClass(this.domNode)); var parent = this.parent; //dojo.debug(parent.containerNode.style.display) if (!parent) return; var index = this.getParentIndex(); this.viewRemoveLayout(); dojo.widget.DomWidget.prototype.removeChild.call(parent, this); var siblingsCount = parent.children.length; //dojo.debug("siblingsCount "+siblingsCount); if (siblingsCount > 0) { if (index == 0) { // deleted first node => update new first parent.children[0].viewUpdateLayout(); } if (index == siblingsCount) { // deleted last node parent.children[siblingsCount-1].viewUpdateLayout(); } } else { if (parent.isTreeNode) { parent.viewSetHasChildren(); } } if (this.tree.unsetFolderOnEmpty && !parent.children.length && parent.isTreeNode) { parent.unsetFolder(); } //dojo.debug(parent.containerNode.style.display) this.parent = null; }, /** * publish destruction event so that controller may unregister/unlisten */ destroy: function() { dojo.event.topic.publish(this.tree.eventNames.beforeNodeDestroy, { source: this } ); this.detach(); return dojo.widget.HtmlWidget.prototype.destroy.apply(this, arguments); }, expand: function(){ if (this.isExpanded) return; //dojo.profile.start("expand "+this); //dojo.debug("expand in "+this); //dojo.profile.start("expand - lazy init "+this); if (this.tryLazyInit) { this.setChildren(); this.tryLazyInit = false; } //dojo.profile.end("expand - lazy init "+this); this.isExpanded = true; this.viewSetExpand(); //dojo.profile.start("expand - showChildren "+this); /** * no matter if I have children or not. need to show/hide container anyway. * use case: empty folder is expanded => then child is added, container already shown all fine */ this.showChildren(); //dojo.profile.end("expand - showChildren "+this); //dojo.profile.end("expand "+this); }, collapse: function(){ if (!this.isExpanded) return; this.isExpanded = false; this.hideChildren(); }, hideChildren: function(){ this.tree.toggleObj.hide( this.containerNode, this.tree.toggleDuration, this.explodeSrc, dojo.lang.hitch(this, "onHideChildren") ); }, showChildren: function(){ //dojo.profile.start("showChildren"+this); this.tree.toggleObj.show( this.containerNode, this.tree.toggleDuration, this.explodeSrc, dojo.lang.hitch(this, "onShowChildren") ); //dojo.profile.end("showChildren"+this); }, onShowChildren: function() { //dojo.profile.start("onShowChildren"+this); this.onShow(); //dojo.profile.end("onShowChildren"+this); dojo.event.topic.publish(this.tree.eventNames.afterExpand, {source: this} ); }, onHideChildren: function() { this.viewSetExpand(); this.onHide(); dojo.event.topic.publish(this.tree.eventNames.afterCollapse, {source: this} ); }, /* Edit current node : change properties and update contents */ setTitle: function(title) { var oldTitle = this.title; this.labelNode.innerHTML = this.title = title; dojo.event.topic.publish(this.tree.eventNames.afterSetTitle, { source: this, oldTitle:oldTitle }); }, toString: function() { return '['+this.widgetType+', '+this.title+']'; } }); /** * Tree model does all the drawing, visual node management etc. * Throws events about clicks on it, so someone may catch them and process * Tree knows nothing about DnD stuff, covered in TreeDragAndDrop and (if enabled) attached by controller */ /** * TODO: use domNode.cloneNode instead of createElement for grid * Should be faster (lyxsus) */ dojo.provide("dojo.widget.TreeV3"); dojo.widget.defineWidget( "dojo.widget.TreeV3", [dojo.widget.HtmlWidget, dojo.widget.TreeWithNode], function() { this.eventNames = {}; this.DndAcceptTypes = []; this.actionsDisabled = []; this.listeners = []; this.tree = this; }, { DndMode: "", /** * factory to generate default widgets */ defaultChildWidget: null, defaultChildTitle: "New Node", // for editing eagerWidgetInstantiation: false, eventNamesDefault: { // tree created.. Perform tree-wide actions if needed afterTreeCreate: "afterTreeCreate", beforeTreeDestroy: "beforeTreeDestroy", /* can't name it "beforeDestroy", because such name causes memleaks in IE */ beforeNodeDestroy: "beforeNodeDestroy", afterChangeTree: "afterChangeTree", afterSetFolder: "afterSetFolder", afterUnsetFolder: "afterUnsetFolder", beforeMoveFrom: "beforeMoveFrom", beforeMoveTo: "beforeMoveTo", afterMoveFrom: "afterMoveFrom", afterMoveTo: "afterMoveTo", afterAddChild: "afterAddChild", afterDetach: "afterDetach", afterExpand: "afterExpand", beforeExpand: "beforeExpand", afterSetTitle: "afterSetTitle", afterCollapse: "afterCollapse", beforeCollapse: "beforeCollapse" }, classPrefix: "Tree", style: "", /** * is it possible to add a new child to leaf ? */ allowAddChildToLeaf: true, /** * when last children is removed from node should it stop being a "folder" ? */ unsetFolderOnEmpty: true, DndModes: { BETWEEN: 1, ONTO: 2 }, DndAcceptTypes: "", // will have cssRoot before it templateCssString:"/* indent for all tree children excepts root */\r\n.TreeNode {\r\n background-image : url('../templates/images/TreeV3/i.gif');\r\n background-position : top left;\r\n background-repeat : repeat-y;\r\n margin-left: 19px;\r\n zoom: 1;\r\n}\r\n.TreeIsRoot {\r\n margin-left: 0;\r\n}\r\n \r\n/* left vertical line (grid) for all nodes */\r\n.TreeIsLast {\r\n background-image: url('../templates/images/TreeV3/i_half.gif');\r\n background-repeat : no-repeat;\r\n}\r\n \r\n.TreeExpandOpen .TreeExpand {\r\n background-image: url('../templates/images/TreeV3/expand_minus.gif');\r\n}\r\n \r\n/* closed is higher priority than open */\r\n.TreeExpandClosed .TreeExpand {\r\n background-image: url('../templates/images/TreeV3/expand_plus.gif');\r\n}\r\n \r\n/* highest priority */\r\n.TreeExpandLeaf .TreeExpand {\r\n background-image: url('../templates/images/TreeV3/expand_leaf.gif');\r\n}\r\n\r\n/* \r\nshould always override any expand setting, but do not touch children.\r\nif I add .TreeExpand .TreeExpandLoading same time and put it to top/bottom, then it will take precedence over +- for all descendants or always fail\r\nso I have to remove TreeExpand and process this one specifically\r\n*/\r\n\r\n.TreeExpandLoading {\r\n width: 18px;\r\n height: 18px;\r\n float: left;\r\n display: inline;\r\n background-repeat : no-repeat;\r\n background-image: url('../templates/images/TreeV3/expand_loading.gif');\r\n}\r\n \r\n.TreeContent {\r\n min-height: 18px;\r\n min-width: 18px;\r\n margin-left:18px;\r\n cursor: default;\r\n /* can't make inline - multiline bugs */\r\n}\r\n\r\n.TreeIEContent {\r\n\theight: 18px;\r\n}\r\n \r\n.TreeExpand {\r\n width: 18px;\r\n height: 18px;\r\n float: left;\r\n display: inline;\r\n background-repeat : no-repeat;\r\n}\r\n \r\n/* same style as IE selection */\r\n.TreeNodeEmphasized {\r\n background-color: Highlight;\r\n color: HighlightText;\r\n}\r\n \r\n.TreeContent .RichTextEditable, .TreeContent .RichTextEditable iframe {\r\n background-color: #ffc;\r\n color: black;\r\n}\r\n\r\n/* don't use :focus due to opera's lack of support on div's */\r\n.TreeLabelFocused {\r\n outline: 1px invert dotted;\r\n}\r\n",templateCssPath: dojo.uri.moduleUri("dojo.widget", "templates/TreeV3.css"), templateString: '<div style="${this.style}">\n</div>', isExpanded: true, // consider this "root node" to be always expanded isTree: true, createNode: function(data) { data.tree = this.widgetId; if (data.widgetName) { // TODO: check if such widget has createSimple return dojo.widget.createWidget(data.widgetName, data); } else if (this.defaultChildWidget.prototype.createSimple) { return this.defaultChildWidget.prototype.createSimple(data); } else { var ns = this.defaultChildWidget.prototype.ns; var wt = this.defaultChildWidget.prototype.widgetType; return dojo.widget.createWidget(ns + ":" + wt, data); } }, // expandNode has +- CSS background. Not img.src for performance, background src string resides in single place. // selection in KHTML/Mozilla disabled treewide, IE requires unselectable for every node // you can add unselectable if you want both in postCreate of tree and in this template // create new template and put into prototype makeNodeTemplate: function() { var domNode = document.createElement("div"); dojo.html.setClass(domNode, this.classPrefix+"Node "+this.classPrefix+"ExpandLeaf "+this.classPrefix+"ChildrenNo"); this.nodeTemplate = domNode; var expandNode = document.createElement("div"); var clazz = this.classPrefix+"Expand"; if (dojo.render.html.ie) { clazz = clazz + ' ' + this.classPrefix+"IEExpand"; } dojo.html.setClass(expandNode, clazz); this.expandNodeTemplate = expandNode; // need <span> inside <div> // div for multiline support, span for styling exactly the text, not whole line var labelNode = document.createElement("span"); dojo.html.setClass(labelNode, this.classPrefix+"Label"); this.labelNodeTemplate = labelNode; var contentNode = document.createElement("div"); var clazz = this.classPrefix+"Content"; /** * IE<7 does not support min-height properly so I have to rely * on this hack * FIXME: do it in CSS only */ if (dojo.render.html.ie && !dojo.render.html.ie70) { clazz = clazz + ' ' + this.classPrefix+"IEContent"; } dojo.html.setClass(contentNode, clazz); this.contentNodeTemplate = contentNode; domNode.appendChild(expandNode); domNode.appendChild(contentNode); contentNode.appendChild(labelNode); }, makeContainerNodeTemplate: function() { var div = document.createElement('div'); div.style.display = 'none'; dojo.html.setClass(div, this.classPrefix+"Container"); this.containerNodeTemplate = div; }, actions: { ADDCHILD: "ADDCHILD" }, getInfo: function() { var info = { widgetId: this.widgetId, objectId: this.objectId } return info; }, adjustEventNames: function() { for(var name in this.eventNamesDefault) { if (dojo.lang.isUndefined(this.eventNames[name])) { this.eventNames[name] = this.widgetId+"/"+this.eventNamesDefault[name]; } } }, adjustDndMode: function() { var _this = this; var DndMode = 0; dojo.lang.forEach(this.DndMode.split(';'), function(elem) { var mode = _this.DndModes[dojo.string.trim(elem).toUpperCase()]; if (mode) DndMode = DndMode | mode; } ); this.DndMode = DndMode; }, /** * publish destruction event so that any listeners should stop listening */ destroy: function() { dojo.event.topic.publish(this.tree.eventNames.beforeTreeDestroy, { source: this } ); return dojo.widget.HtmlWidget.prototype.destroy.apply(this, arguments); }, initialize: function(args){ this.domNode.widgetId = this.widgetId; for(var i=0; i<this.actionsDisabled.length;i++) { this.actionsDisabled[i] = this.actionsDisabled[i].toUpperCase(); } //dojo.debug(args.defaultChildWidget ? true : false) if (!args.defaultChildWidget) { this.defaultChildWidget = dojo.widget.TreeNodeV3; } else { this.defaultChildWidget = dojo.lang.getObjPathValue(args.defaultChildWidget); } this.adjustEventNames(); this.adjustDndMode(); this.makeNodeTemplate(); this.makeContainerNodeTemplate(); this.containerNode = this.domNode; dojo.html.setClass(this.domNode, this.classPrefix+"Container"); var _this = this; //dojo.html.disableSelection(this.domNode) dojo.lang.forEach(this.listeners, function(elem) { var t = dojo.lang.isString(elem) ? dojo.widget.byId(elem) : elem; t.listenTree(_this) } ); }, postCreate: function() { dojo.event.topic.publish(this.eventNames.afterTreeCreate, { source: this } ); }, /** * Move child to newParent as last child * redraw tree and update icons. * * Called by target, saves source in event. * events are published for BOTH trees AFTER update. */ move: function(child, newParent, index) { if (!child.parent) { dojo.raise(this.widgetType+": child can be moved only while it's attached"); } var oldParent = child.parent; var oldTree = child.tree; var oldIndex = child.getParentIndex(); var newTree = newParent.tree; var newParent = newParent; var newIndex = index; var message = { oldParent: oldParent, oldTree: oldTree, oldIndex: oldIndex, newParent: newParent, newTree: newTree, newIndex: newIndex, child: child }; dojo.event.topic.publish(oldTree.eventNames.beforeMoveFrom, message); dojo.event.topic.publish(newTree.eventNames.beforeMoveTo, message); this.doMove.apply(this, arguments); /* publish events here about structural changes for both source and target trees */ dojo.event.topic.publish(oldTree.eventNames.afterMoveFrom, message); dojo.event.topic.publish(newTree.eventNames.afterMoveTo, message); }, /* do actual parent change here. Write remove child first */ doMove: function(child, newParent, index) { //dojo.debug("MOVE "+child+" to "+newParent+" at "+index); //var parent = child.parent; child.doDetach(); //dojo.debug("addChild "+child+" to "+newParent+" at "+index); newParent.doAddChild(child, index); }, toString: function() { return "["+this.widgetType+" ID:"+this.widgetId +"]" } }); dojo.provide("dojo.AdapterRegistry"); dojo.AdapterRegistry = function(/*Boolean?*/ returnWrappers){ // summary: // A registry to make contextual calling/searching easier. // description: // Objects of this class keep list of arrays in the form [name, check, // wrap, directReturn] that are used to determine what the contextual // result of a set of checked arguments is. All check/wrap functions // in this registry should be of the same arity. this.pairs = []; this.returnWrappers = returnWrappers || false; } dojo.lang.extend(dojo.AdapterRegistry, { register: function(name, check, /*Function*/ wrap, directReturn, override){ // summary: // register a check function to determine if the wrap function or // object gets selected // name: String // a way to identify this matcher. // check: Function // a function that arguments are passed to from the adapter's // match() function. The check function should return true if the // given arguments are appropriate for the wrap function. // directReturn: Boolean? // If directReturn is true, the value passed in for wrap will be // returned instead of being called. Alternately, the // AdapterRegistry can be set globally to "return not call" using // the returnWrappers property. Either way, this behavior allows // the registry to act as a "search" function instead of a // function interception library. // override: Boolean? // If override is given and true, the check function will be given // highest priority. Otherwise, it will be the lowest priority // adapter. var type = (override) ? "unshift" : "push"; this.pairs[type]([name, check, wrap, directReturn]); }, match: function(/* ... */){ // summary: // Find an adapter for the given arguments. If no suitable adapter // is found, throws an exception. match() accepts any number of // arguments, all of which are passed to all matching functions // from the registered pairs. for(var i = 0; i < this.pairs.length; i++){ var pair = this.pairs[i]; if(pair[1].apply(this, arguments)){ if((pair[3])||(this.returnWrappers)){ return pair[2]; }else{ return pair[2].apply(this, arguments); } } } throw new Error("No match found"); // dojo.raise("No match found"); }, unregister: function(name){ // summary: Remove a named adapter from the registry // FIXME: this is kind of a dumb way to handle this. On a large // registry this will be slow-ish and we can use the name as a lookup // should we choose to trade memory for speed. for(var i = 0; i < this.pairs.length; i++){ var pair = this.pairs[i]; if(pair[0] == name){ this.pairs.splice(i, 1); return true; } } return false; } }); dojo.provide("dojo.json"); dojo.json = { // jsonRegistry: AdapterRegistry a registry of type-based serializers jsonRegistry: new dojo.AdapterRegistry(), register: function( /*String*/ name, /*function*/ check, /*function*/ wrap, /*optional, boolean*/ override){ // summary: // Register a JSON serialization function. JSON serialization // functions should take one argument and return an object // suitable for JSON serialization: // - string // - number // - boolean // - undefined // - object // - null // - Array-like (length property that is a number) // - Objects with a "json" method will have this method called // - Any other object will be used as {key:value, ...} pairs // // If override is given, it is used as the highest priority JSON // serialization, otherwise it will be used as the lowest. // name: // a descriptive type for this serializer // check: // a unary function that will be passed an object to determine // whether or not wrap will be used to serialize the object // wrap: // the serialization function // override: // optional, determines if the this serialization function will be // given priority in the test order dojo.json.jsonRegistry.register(name, check, wrap, override); }, evalJson: function(/*String*/ json){ // summary: // evaluates the passed string-form of a JSON object // json: // a string literal of a JSON item, for instance: // '{ "foo": [ "bar", 1, { "baz": "thud" } ] }' // return: // the result of the evaluation // FIXME: should this accept mozilla's optional second arg? try { return eval("(" + json + ")"); }catch(e){ dojo.debug(e); return json; } }, serialize: function(/*Object*/ o){ // summary: // Create a JSON serialization of an object, note that this // doesn't check for infinite recursion, so don't do that! // o: // an object to be serialized. Objects may define their own // serialization via a special "__json__" or "json" function // property. If a specialized serializer has been defined, it will // be used as a fallback. // return: // a String representing the serialized version of the passed // object var objtype = typeof(o); if(objtype == "undefined"){ return "undefined"; }else if((objtype == "number")||(objtype == "boolean")){ return o + ""; }else if(o === null){ return "null"; } if (objtype == "string") { return dojo.string.escapeString(o); } // recurse var me = arguments.callee; // short-circuit for objects that support "json" serialization // if they return "self" then just pass-through... var newObj; if(typeof(o.__json__) == "function"){ newObj = o.__json__(); if(o !== newObj){ return me(newObj); } } if(typeof(o.json) == "function"){ newObj = o.json(); if (o !== newObj) { return me(newObj); } } // array if(objtype != "function" && typeof(o.length) == "number"){ var res = []; for(var i = 0; i < o.length; i++){ var val = me(o[i]); if(typeof(val) != "string"){ val = "undefined"; } res.push(val); } return "[" + res.join(",") + "]"; } // look in the registry try { window.o = o; newObj = dojo.json.jsonRegistry.match(o); return me(newObj); }catch(e){ // dojo.debug(e); } // it's a function with no adapter, bad if(objtype == "function"){ return null; } // generic object code path res = []; for (var k in o){ var useKey; if (typeof(k) == "number"){ useKey = '"' + k + '"'; }else if (typeof(k) == "string"){ useKey = dojo.string.escapeString(k); }else{ // skip non-string or number keys continue; } val = me(o[k]); if(typeof(val) != "string"){ // skip non-serializable values continue; } res.push(useKey + ":" + val); } return "{" + res.join(",") + "}"; } }; dojo.provide("dojo.dnd.DragAndDrop"); // summary: // Core "interfaces" for the participants in all DnD operations. // Subclasses implement all of the actions outlined by these APIs, with // most of the ones you probably care about being defined in // HtmlDragAndDrop.js, which will be automatically included should you // . // // In addition to the various actor classes, a global manager will be // created/installed at dojo.dnd.dragManager. This manager object is of // type dojo.dnd.DragManager and will be replaced by environment-specific // managers. // // The 3 object types involved in any Drag and Drop operation are: // * DragSource // This is the item that can be selected for dragging. Drag // sources can have "types" to help mediate whether or not various // DropTargets will accept (or reject them). Most dragging actions // are handled by the DragObject which the DragSource generates // from its onDragStart method. // * DragObject // This, along with the manger, does most of the hard work of DnD. // Implementations may rely on DragObject instances to implement // "shadowing", "movement", or other kinds of DnD variations that // affect the visual representation of the drag operation. // * DropTarget // Represents some section of the screen that can accept drag // and drop events. DropTargets keep a list of accepted types // which is checked agains the types of the respective DragSource // objects that pass over it. DropTargets may implement behaviors // that respond to drop events to take application-level actions. dojo.declare("dojo.dnd.DragSource", null, { // String: // what kind of drag source are we? Used to determine if we can be // dropped on a given DropTarget type: "", onDragEnd: function(/*dojo.dnd.DragEvent*/evt){ // summary: // stub handler that is called when dragging finishes. }, onDragStart: function(/*dojo.dnd.DragEvent*/evt){ // dojo.dnd.DragObject // summary: // stub handler that is called when dragging starts. Subclasses // should ensure that onDragStart *always* returns a // dojo.dnd.DragObject instance. }, onSelected: function(/*dojo.dnd.DragEvent*/evt){ // summary: // This function gets called when the DOM element was selected for // dragging by the HtmlDragAndDropManager. }, unregister: function(){ // summary: remove this drag source from the manager dojo.dnd.dragManager.unregisterDragSource(this); }, reregister: function(){ // summary: add this drag source to the manager dojo.dnd.dragManager.registerDragSource(this); } }); dojo.declare("dojo.dnd.DragObject", null, { // String: // what kind of drag object are we? Used to determine if we can be // dropped on a given DropTarget type: "", register: function(){ // summary: register this DragObject with the manager var dm = dojo.dnd.dragManager; if(dm["registerDragObject"]){ // side-effect prevention dm.registerDragObject(this); } }, onDragStart: function(/*dojo.dnd.DragEvent*/evt){ // summary: // over-ridden by subclasses. Gets called directly after being // created by the DragSource default action is to clone self as // icon }, onDragMove: function(/*dojo.dnd.DragEvent*/evt){ // summary: // Implemented by subclasses. Should change the UI for the drag // icon i.e., "it moves itself" }, onDragOver: function(/*dojo.dnd.DragEvent*/evt){ // summary: // stub handler that is called when the DragObject instance is // "over" a DropTarget. }, onDragOut: function(/*dojo.dnd.DragEvent*/evt){ // summary: // stub handler that is called when the DragObject instance leaves // a DropTarget. }, onDragEnd: function(/*dojo.dnd.DragEvent*/evt){ // summary: // stub handler that is called when dragging ends, either through // dropping or cancelation. }, // normal aliases onDragLeave: dojo.lang.forward("onDragOut"), onDragEnter: dojo.lang.forward("onDragOver"), // non-camel aliases ondragout: dojo.lang.forward("onDragOut"), ondragover: dojo.lang.forward("onDragOver") }); dojo.declare("dojo.dnd.DropTarget", null, { acceptsType: function(/*String*/type){ // summary: // determines whether or not this DropTarget will accept the given // type. The default behavior is to consult this.acceptedTypes and // if "*" is a member, to always accept the type. if(!dojo.lang.inArray(this.acceptedTypes, "*")){ // wildcard if(!dojo.lang.inArray(this.acceptedTypes, type)) { return false; } // Boolean } return true; // Boolean }, accepts: function(/*Array*/dragObjects){ // summary: // determines if we'll accept all members of the passed array of // dojo.dnd.DragObject instances if(!dojo.lang.inArray(this.acceptedTypes, "*")){ // wildcard for (var i = 0; i < dragObjects.length; i++) { if (!dojo.lang.inArray(this.acceptedTypes, dragObjects[i].type)) { return false; } // Boolean } } return true; // Boolean }, unregister: function(){ // summary: remove from the drag manager dojo.dnd.dragManager.unregisterDropTarget(this); }, onDragOver: function(/*dojo.dnd.DragEvent*/evt){ // summary: // stub handler that is called when DragObject instances are // "over" this DropTarget. }, onDragOut: function(/*dojo.dnd.DragEvent*/evt){ // summary: // stub handler that is called when DragObject instances are // "leave" this DropTarget. }, onDragMove: function(/*dojo.dnd.DragEvent*/evt){ // summary: // stub handler that is called when DragObject instances are // moved across this DropTarget. May fire many times in the course // of the drag operation but will end after onDragOut }, onDropStart: function(/*dojo.dnd.DragEvent*/evt){ // Boolean // summary: // stub handler that is called when DragObject instances are // dropped on this target. If true is returned from onDropStart, // dropping proceeds, otherwise it's cancled. }, onDrop: function(/*dojo.dnd.DragEvent*/evt){ // summary: we're getting dropped on! }, onDropEnd: function(){ // summary: dropping is over } }, function(){ this.acceptedTypes = []; }); // NOTE: this interface is defined here for the convenience of the DragManager // implementor. It is expected that in most cases it will be satisfied by // extending a native event (DOM event in HTML and SVG). dojo.dnd.DragEvent = function(){ this.dragSource = null; this.dragObject = null; this.target = null; this.eventStatus = "success"; // // can be one of: // [ "dropSuccess", "dropFailure", "dragMove", // "dragStart", "dragEnter", "dragLeave"] // } /* * The DragManager handles listening for low-level events and dispatching * them to higher-level primitives like drag sources and drop targets. In * order to do this, it must keep a list of the items. */ dojo.declare("dojo.dnd.DragManager", null, { // Array: an array of currently selected DragSource objects selectedSources: [], // Array: all DragObjects we know about dragObjects: [], // Array: all DragSources we know about dragSources: [], registerDragSource: function(/*dojo.dnd.DragSource*/ source){ // summary: called by DragSource class constructor }, // Array: all DropTargets we know about dropTargets: [], registerDropTarget: function(/*dojo.dnd.DropTarget*/ target){ // summary: called by DropTarget class constructor }, // dojo.dnd.DropTarget: // what was the last DropTarget instance we left in the drag phase? lastDragTarget: null, // dojo.dnd.DropTarget: // the DropTarget the mouse is currently over currentDragTarget: null, onKeyDown: function(){ // summary: generic handler called by low-level events }, onMouseOut: function(){ // summary: generic handler called by low-level events }, onMouseMove: function(){ // summary: generic handler called by low-level events }, onMouseUp: function(){ // summary: generic handler called by low-level events } }); // NOTE: despite the existance of the DragManager class, there will be a // singleton drag manager provided by the renderer-specific D&D support code. // It is therefore sane for us to assign instance variables to the DragManager // prototype // The renderer-specific file will define the following object: // dojo.dnd.dragManager = null; dojo.provide("dojo.dnd.HtmlDragManager"); // NOTE: there will only ever be a single instance of HTMLDragManager, so it's // safe to use prototype properties for book-keeping. dojo.declare("dojo.dnd.HtmlDragManager", dojo.dnd.DragManager, { /** * There are several sets of actions that the DnD code cares about in the * HTML context: * 1.) mouse-down -> * (draggable selection) * (dragObject generation) * mouse-move -> * (draggable movement) * (droppable detection) * (inform droppable) * (inform dragObject) * mouse-up * (inform/destroy dragObject) * (inform draggable) * (inform droppable) * 2.) mouse-down -> mouse-down * (click-hold context menu) * 3.) mouse-click -> * (draggable selection) * shift-mouse-click -> * (augment draggable selection) * mouse-down -> * (dragObject generation) * mouse-move -> * (draggable movement) * (droppable detection) * (inform droppable) * (inform dragObject) * mouse-up * (inform draggable) * (inform droppable) * 4.) mouse-up * (clobber draggable selection) */ disabled: false, // to kill all dragging! nestedTargets: false, mouseDownTimer: null, // used for click-hold operations dsCounter: 0, dsPrefix: "dojoDragSource", // dimension calculation cache for use durring drag dropTargetDimensions: [], currentDropTarget: null, // currentDropTargetPoints: null, previousDropTarget: null, _dragTriggered: false, selectedSources: [], dragObjects: [], dragSources: [], dropTargets: [], // mouse position properties currentX: null, currentY: null, lastX: null, lastY: null, mouseDownX: null, mouseDownY: null, threshold: 7, dropAcceptable: false, cancelEvent: function(e){ e.stopPropagation(); e.preventDefault();}, // method over-rides registerDragSource: function(ds){ //dojo.profile.start("register DragSource"); if(ds["domNode"]){ // FIXME: dragSource objects SHOULD have some sort of property that // references their DOM node, we shouldn't just be passing nodes and // expecting it to work. //dojo.profile.start("register DragSource 1"); var dp = this.dsPrefix; var dpIdx = dp+"Idx_"+(this.dsCounter++); ds.dragSourceId = dpIdx; this.dragSources[dpIdx] = ds; ds.domNode.setAttribute(dp, dpIdx); //dojo.profile.end("register DragSource 1"); //dojo.profile.start("register DragSource 2"); // so we can drag links if(dojo.render.html.ie){ //dojo.profile.start("register DragSource IE"); dojo.event.browser.addListener(ds.domNode, "ondragstart", this.cancelEvent); // terribly slow //dojo.event.connect(ds.domNode, "ondragstart", this.cancelEvent); //dojo.profile.end("register DragSource IE"); } //dojo.profile.end("register DragSource 2"); } //dojo.profile.end("register DragSource"); }, unregisterDragSource: function(ds){ if (ds["domNode"]){ var dp = this.dsPrefix; var dpIdx = ds.dragSourceId; delete ds.dragSourceId; delete this.dragSources[dpIdx]; ds.domNode.setAttribute(dp, null); if(dojo.render.html.ie){ dojo.event.browser.removeListener(ds.domNode, "ondragstart", this.cancelEvent); } } }, registerDropTarget: function(dt){ this.dropTargets.push(dt); }, unregisterDropTarget: function(dt){ var index = dojo.lang.find(this.dropTargets, dt, true); if (index>=0) { this.dropTargets.splice(index, 1); } }, /** * Get the DOM element that is meant to drag. * Loop through the parent nodes of the event target until * the element is found that was created as a DragSource and * return it. * * @param event object The event for which to get the drag source. */ getDragSource: function(e){ var tn = e.target; if(tn === dojo.body()){ return; } var ta = dojo.html.getAttribute(tn, this.dsPrefix); while((!ta)&&(tn)){ tn = tn.parentNode; if((!tn)||(tn === dojo.body())){ return; } ta = dojo.html.getAttribute(tn, this.dsPrefix); } return this.dragSources[ta]; }, onKeyDown: function(e){ }, onMouseDown: function(e){ if(this.disabled) { return; } // only begin on left click if(dojo.render.html.ie) { if(e.button != 1) { return; } } else if(e.which != 1) { return; } var target = e.target.nodeType == dojo.html.TEXT_NODE ? e.target.parentNode : e.target; // do not start drag involvement if the user is interacting with // a form element. if(dojo.html.isTag(target, "button", "textarea", "input", "select", "option")) { return; } // find a selection object, if one is a parent of the source node var ds = this.getDragSource(e); // this line is important. if we aren't selecting anything then // we need to return now, so preventDefault() isn't called, and thus // the event is propogated to other handling code if(!ds){ return; } if(!dojo.lang.inArray(this.selectedSources, ds)){ this.selectedSources.push(ds); ds.onSelected(); } this.mouseDownX = e.pageX; this.mouseDownY = e.pageY; // Must stop the mouse down from being propogated, or otherwise can't // drag links in firefox. // WARNING: preventing the default action on all mousedown events // prevents user interaction with the contents. e.preventDefault(); dojo.event.connect(document, "onmousemove", this, "onMouseMove"); }, onMouseUp: function(e, cancel){ // if we aren't dragging then ignore the mouse-up // (in particular, don't call preventDefault(), because other // code may need to process this event) if(this.selectedSources.length==0){ return; } this.mouseDownX = null; this.mouseDownY = null; this._dragTriggered = false; // e.preventDefault(); e.dragSource = this.dragSource; // let ctrl be used for multiselect or another action // if I use same key to trigger treeV3 node selection and here, // I have bugs with drag'n'drop. why ?? no idea.. if((!e.shiftKey)&&(!e.ctrlKey)){ //if(!e.shiftKey){ if(this.currentDropTarget) { this.currentDropTarget.onDropStart(); } dojo.lang.forEach(this.dragObjects, function(tempDragObj){ var ret = null; if(!tempDragObj){ return; } if(this.currentDropTarget) { e.dragObject = tempDragObj; // NOTE: we can't get anything but the current drop target // here since the drag shadow blocks mouse-over events. // This is probelematic for dropping "in" something var ce = this.currentDropTarget.domNode.childNodes; if(ce.length > 0){ e.dropTarget = ce[0]; while(e.dropTarget == tempDragObj.domNode){ e.dropTarget = e.dropTarget.nextSibling; } }else{ e.dropTarget = this.currentDropTarget.domNode; } if(this.dropAcceptable){ ret = this.currentDropTarget.onDrop(e); }else{ this.currentDropTarget.onDragOut(e); } } e.dragStatus = this.dropAcceptable && ret ? "dropSuccess" : "dropFailure"; // decouple the calls for onDragEnd, so they don't block the execution here // ie. if the onDragEnd would call an alert, the execution here is blocked until the // user has confirmed the alert box and then the rest of the dnd code is executed // while the mouse doesnt "hold" the dragged object anymore ... and so on dojo.lang.delayThese([ function() { // in FF1.5 this throws an exception, see // http://dojotoolkit.org/pipermail/dojo-interest/2006-April/006751.html try{ tempDragObj.dragSource.onDragEnd(e) } catch(err) { // since the problem seems passing e, we just copy all // properties and try the copy ... var ecopy = {}; for (var i in e) { if (i=="type") { // the type property contains the exception, no idea why... ecopy.type = "mouseup"; continue; } ecopy[i] = e[i]; } tempDragObj.dragSource.onDragEnd(ecopy); } } , function() {tempDragObj.onDragEnd(e)}]); }, this); this.selectedSources = []; this.dragObjects = []; this.dragSource = null; if(this.currentDropTarget) { this.currentDropTarget.onDropEnd(); } } else { //dojo.debug("special click"); } dojo.event.disconnect(document, "onmousemove", this, "onMouseMove"); this.currentDropTarget = null; }, onScroll: function(){ //dojo.profile.start("DNDManager updateoffset"); for(var i = 0; i < this.dragObjects.length; i++) { if(this.dragObjects[i].updateDragOffset) { this.dragObjects[i].updateDragOffset(); } } //dojo.profile.end("DNDManager updateoffset"); // TODO: do not recalculate, only adjust coordinates if (this.dragObjects.length) { this.cacheTargetLocations(); } }, _dragStartDistance: function(x, y){ if((!this.mouseDownX)||(!this.mouseDownX)){ return; } var dx = Math.abs(x-this.mouseDownX); var dx2 = dx*dx; var dy = Math.abs(y-this.mouseDownY); var dy2 = dy*dy; return parseInt(Math.sqrt(dx2+dy2), 10); }, cacheTargetLocations: function(){ dojo.profile.start("cacheTargetLocations"); this.dropTargetDimensions = []; dojo.lang.forEach(this.dropTargets, function(tempTarget){ var tn = tempTarget.domNode; //only cache dropTarget which can accept current dragSource if(!tn || !tempTarget.accepts([this.dragSource])){ return; } var abs = dojo.html.getAbsolutePosition(tn, true); var bb = dojo.html.getBorderBox(tn); this.dropTargetDimensions.push([ [abs.x, abs.y], // upper-left // lower-right [ abs.x+bb.width, abs.y+bb.height ], tempTarget ]); //dojo.debug("Cached for "+tempTarget) }, this); dojo.profile.end("cacheTargetLocations"); //dojo.debug("Cache locations") }, onMouseMove: function(e){ if((dojo.render.html.ie)&&(e.button != 1)){ // Oooops - mouse up occurred - e.g. when mouse was not over the // window. I don't think we can detect this for FF - but at least // we can be nice in IE. this.currentDropTarget = null; this.onMouseUp(e, true); return; } // if we've got some sources, but no drag objects, we need to send // onDragStart to all the right parties and get things lined up for // drop target detection if( (this.selectedSources.length)&& (!this.dragObjects.length) ){ var dx; var dy; if(!this._dragTriggered){ this._dragTriggered = (this._dragStartDistance(e.pageX, e.pageY) > this.threshold); if(!this._dragTriggered){ return; } dx = e.pageX - this.mouseDownX; dy = e.pageY - this.mouseDownY; } // the first element is always our dragSource, if there are multiple // selectedSources (elements that move along) then the first one is the master // and for it the events will be fired etc. this.dragSource = this.selectedSources[0]; dojo.lang.forEach(this.selectedSources, function(tempSource){ if(!tempSource){ return; } var tdo = tempSource.onDragStart(e); if(tdo){ tdo.onDragStart(e); // "bump" the drag object to account for the drag threshold tdo.dragOffset.y += dy; tdo.dragOffset.x += dx; tdo.dragSource = tempSource; this.dragObjects.push(tdo); } }, this); /* clean previous drop target in dragStart */ this.previousDropTarget = null; this.cacheTargetLocations(); } // FIXME: we need to add dragSources and dragObjects to e dojo.lang.forEach(this.dragObjects, function(dragObj){ if(dragObj){ dragObj.onDragMove(e); } }); // if we have a current drop target, check to see if we're outside of // it. If so, do all the actions that need doing. if(this.currentDropTarget){ //dojo.debug(dojo.html.hasParent(this.currentDropTarget.domNode)) var c = dojo.html.toCoordinateObject(this.currentDropTarget.domNode, true); // var dtp = this.currentDropTargetPoints; var dtp = [ [c.x,c.y], [c.x+c.width, c.y+c.height] ]; } if((!this.nestedTargets)&&(dtp)&&(this.isInsideBox(e, dtp))){ if(this.dropAcceptable){ this.currentDropTarget.onDragMove(e, this.dragObjects); } }else{ // FIXME: need to fix the event object! // see if we can find a better drop target var bestBox = this.findBestTarget(e); if(bestBox.target === null){ if(this.currentDropTarget){ this.currentDropTarget.onDragOut(e); this.previousDropTarget = this.currentDropTarget; this.currentDropTarget = null; // this.currentDropTargetPoints = null; } this.dropAcceptable = false; return; } if(this.currentDropTarget !== bestBox.target){ if(this.currentDropTarget){ this.previousDropTarget = this.currentDropTarget; this.currentDropTarget.onDragOut(e); } this.currentDropTarget = bestBox.target; // this.currentDropTargetPoints = bestBox.points; e.dragObjects = this.dragObjects; this.dropAcceptable = this.currentDropTarget.onDragOver(e); }else{ if(this.dropAcceptable){ this.currentDropTarget.onDragMove(e, this.dragObjects); } } } }, findBestTarget: function(e) { var _this = this; var bestBox = new Object(); bestBox.target = null; bestBox.points = null; dojo.lang.every(this.dropTargetDimensions, function(tmpDA) { if(!_this.isInsideBox(e, tmpDA)){ return true; } bestBox.target = tmpDA[2]; bestBox.points = tmpDA; // continue iterating only if _this.nestedTargets == true return Boolean(_this.nestedTargets); }); return bestBox; }, isInsideBox: function(e, coords){ if( (e.pageX > coords[0][0])&& (e.pageX < coords[1][0])&& (e.pageY > coords[0][1])&& (e.pageY < coords[1][1]) ){ return true; } return false; }, onMouseOver: function(e){ }, onMouseOut: function(e){ } }); dojo.dnd.dragManager = new dojo.dnd.HtmlDragManager(); // global namespace protection closure (function(){ var d = document; var dm = dojo.dnd.dragManager; //TODO: when focus manager is ready, dragManager should be rewritten to use it // set up event handlers on the document (or no?) dojo.event.connect(d, "onkeydown", dm, "onKeyDown"); dojo.event.connect(d, "onmouseover", dm, "onMouseOver"); dojo.event.connect(d, "onmouseout", dm, "onMouseOut"); dojo.event.connect(d, "onmousedown", dm, "onMouseDown"); dojo.event.connect(d, "onmouseup", dm, "onMouseUp"); // TODO: process scrolling of elements, not only window (focus manager would // probably come to rescue here as well) dojo.event.connect(window, "onscroll", dm, "onScroll"); })(); dojo.provide("dojo.dnd.HtmlDragAndDrop"); dojo.declare("dojo.dnd.HtmlDragSource", dojo.dnd.DragSource, { dragClass: "", // CSS classname(s) applied to node when it is being dragged onDragStart: function(){ var dragObj = new dojo.dnd.HtmlDragObject(this.dragObject, this.type); if(this.dragClass){ dragObj.dragClass = this.dragClass; } if(this.constrainToContainer){ dragObj.constrainTo(this.constrainingContainer || this.domNode.parentNode); } return dragObj; }, setDragHandle: function(node){ node = dojo.byId(node); dojo.dnd.dragManager.unregisterDragSource(this); this.domNode = node; dojo.dnd.dragManager.registerDragSource(this); }, setDragTarget: function(node){ this.dragObject = node; }, constrainTo: function(container){ this.constrainToContainer = true; if(container){ this.constrainingContainer = container; } }, /* * * see dojo.dnd.DragSource.onSelected */ onSelected: function(){ for(var i=0; i<this.dragObjects.length; i++){ dojo.dnd.dragManager.selectedSources.push(new dojo.dnd.HtmlDragSource(this.dragObjects[i])); } }, /** * Register elements that should be dragged along with * the actual DragSource. * * Example usage: * var dragSource = new dojo.dnd.HtmlDragSource(...); * // add a single element * dragSource.addDragObjects(dojo.byId('id1')); * // add multiple elements to drag along * dragSource.addDragObjects('id2', dojo.byId('id3')); * * el A dom node to add to the drag list. */ addDragObjects: function(/*DOMNode*/ el){ for(var i=0; i<arguments.length; i++){ this.dragObjects.push(dojo.byId(arguments[i])); } } }, function(node, type){ node = dojo.byId(node); this.dragObjects = []; this.constrainToContainer = false; if(node){ this.domNode = node; this.dragObject = node; // set properties that might have been clobbered by the mixin this.type = (type)||(this.domNode.nodeName.toLowerCase()); dojo.dnd.DragSource.prototype.reregister.call(this); } } ); dojo.declare("dojo.dnd.HtmlDragObject", dojo.dnd.DragObject, { dragClass: "", opacity: 0.5, createIframe: true, // workaround IE6 bug // if true, node will not move in X and/or Y direction disableX: false, disableY: false, createDragNode: function() { var node = this.domNode.cloneNode(true); if(this.dragClass) { dojo.html.addClass(node, this.dragClass); } if(this.opacity < 1) { dojo.html.setOpacity(node, this.opacity); } var ltn = node.tagName.toLowerCase(); var isTr = (ltn == "tr"); if((isTr)||(ltn == "tbody")){ // dojo.debug("Dragging table row") // Create a table for the cloned row var doc = this.domNode.ownerDocument; var table = doc.createElement("table"); if(isTr){ var tbody = doc.createElement("tbody"); table.appendChild(tbody); tbody.appendChild(node); }else{ table.appendChild(node); } // Set a fixed width to the cloned TDs var tmpSrcTr = ((isTr) ? this.domNode : this.domNode.firstChild); var tmpDstTr = ((isTr) ? node : node.firstChild); var domTds = tmpSrcTr.childNodes; var cloneTds = tmpDstTr.childNodes; for(var i = 0; i < domTds.length; i++){ if((cloneTds[i])&&(cloneTds[i].style)){ cloneTds[i].style.width = dojo.html.getContentBox(domTds[i]).width + "px"; } } node = table; } if((dojo.render.html.ie55||dojo.render.html.ie60) && this.createIframe){ with(node.style) { top="0px"; left="0px"; } var outer = document.createElement("div"); outer.appendChild(node); this.bgIframe = new dojo.html.BackgroundIframe(outer); outer.appendChild(this.bgIframe.iframe); node = outer; } node.style.zIndex = 999; return node; }, onDragStart: function(e){ dojo.html.clearSelection(); this.scrollOffset = dojo.html.getScroll().offset; this.dragStartPosition = dojo.html.getAbsolutePosition(this.domNode, true); this.dragOffset = {y: this.dragStartPosition.y - e.pageY, x: this.dragStartPosition.x - e.pageX}; this.dragClone = this.createDragNode(); this.containingBlockPosition = this.domNode.offsetParent ? dojo.html.getAbsolutePosition(this.domNode.offsetParent, true) : {x:0, y:0}; if(this.constrainToContainer){ this.constraints = this.getConstraints(); } // set up for dragging with(this.dragClone.style){ position = "absolute"; top = this.dragOffset.y + e.pageY + "px"; left = this.dragOffset.x + e.pageX + "px"; } dojo.body().appendChild(this.dragClone); dojo.event.topic.publish('dragStart', { source: this } ); }, /** Return min/max x/y (relative to document.body) for this object) **/ getConstraints: function(){ if(this.constrainingContainer.nodeName.toLowerCase() == 'body'){ var viewport = dojo.html.getViewport(); var width = viewport.width; var height = viewport.height; var scroll = dojo.html.getScroll().offset; var x = scroll.x; var y = scroll.y; }else{ var content = dojo.html.getContentBox(this.constrainingContainer); width = content.width; height = content.height; x = this.containingBlockPosition.x + dojo.html.getPixelValue(this.constrainingContainer, "padding-left", true) + dojo.html.getBorderExtent(this.constrainingContainer, "left"); y = this.containingBlockPosition.y + dojo.html.getPixelValue(this.constrainingContainer, "padding-top", true) + dojo.html.getBorderExtent(this.constrainingContainer, "top"); } // TODO: should handle left/top/right/bottom margin separately; left/top should affect minX/minY var mb = dojo.html.getMarginBox(this.domNode); return { minX: x, minY: y, maxX: x + width - mb.width, maxY: y + height - mb.height } }, updateDragOffset: function(){ var scroll = dojo.html.getScroll().offset; if(scroll.y != this.scrollOffset.y){ var diff = scroll.y - this.scrollOffset.y; this.dragOffset.y += diff; this.scrollOffset.y = scroll.y; } if(scroll.x != this.scrollOffset.x){ var diff = scroll.x - this.scrollOffset.x; this.dragOffset.x += diff; this.scrollOffset.x = scroll.x; } }, /** Moves the node to follow the mouse */ onDragMove: function(e){ this.updateDragOffset(); var x = this.dragOffset.x + e.pageX; var y = this.dragOffset.y + e.pageY; if (this.constrainToContainer) { if (x < this.constraints.minX) { x = this.constraints.minX; } if (y < this.constraints.minY) { y = this.constraints.minY; } if (x > this.constraints.maxX) { x = this.constraints.maxX; } if (y > this.constraints.maxY) { y = this.constraints.maxY; } } this.setAbsolutePosition(x, y); dojo.event.topic.publish('dragMove', { source: this } ); }, /** * Set the position of the drag clone. (x,y) is relative to <body>. */ setAbsolutePosition: function(x, y){ // The drag clone is attached to document.body so this is trivial if(!this.disableY) { this.dragClone.style.top = y + "px"; } if(!this.disableX) { this.dragClone.style.left = x + "px"; } }, /** * If the drag operation returned a success we remove the clone of * ourself from the original position. If the drag operation returned * failure we slide back over to where we came from and end the operation * with a little grace. */ onDragEnd: function(e){ switch(e.dragStatus){ case "dropSuccess": dojo.html.removeNode(this.dragClone); this.dragClone = null; break; case "dropFailure": // slide back to the start var startCoords = dojo.html.getAbsolutePosition(this.dragClone, true); // offset the end so the effect can be seen var endCoords = { left: this.dragStartPosition.x + 1, top: this.dragStartPosition.y + 1}; // animate var anim = dojo.lfx.slideTo(this.dragClone, endCoords, 300); var dragObject = this; dojo.event.connect(anim, "onEnd", function(e){ // pause for a second (not literally) and disappear // dojo.lang.setTimeout(function() { dojo.html.removeNode(dragObject.dragClone); // Allow drag clone to be gc'ed dragObject.dragClone = null; // }, // 50); }); anim.play(); break; } dojo.event.topic.publish('dragEnd', { source: this } ); }, constrainTo: function(container){ this.constrainToContainer=true; if(container){ this.constrainingContainer = container; }else{ this.constrainingContainer = this.domNode.parentNode; } } }, function(node, type){ this.domNode = dojo.byId(node); this.type = type; this.constrainToContainer = false; this.dragSource = null; // this.register(); dojo.dnd.DragObject.prototype.register.call(this); } ); dojo.declare("dojo.dnd.HtmlDropTarget", dojo.dnd.DropTarget, { vertical: false, onDragOver: function(e){ if(!this.accepts(e.dragObjects)){ return false; } // cache the positions of the child nodes this.childBoxes = []; for(var i = 0, child; i < this.domNode.childNodes.length; i++){ child = this.domNode.childNodes[i]; if(child.nodeType != dojo.html.ELEMENT_NODE){ continue; } var pos = dojo.html.getAbsolutePosition(child, true); var inner = dojo.html.getBorderBox(child); this.childBoxes.push({top: pos.y, bottom: pos.y+inner.height, left: pos.x, right: pos.x+inner.width, height: inner.height, width: inner.width, node: child}); } // TODO: use dummy node return true; }, _getNodeUnderMouse: function(e){ // find the child for(var i = 0, child; i < this.childBoxes.length; i++){ with(this.childBoxes[i]){ if (e.pageX >= left && e.pageX <= right && e.pageY >= top && e.pageY <= bottom){ return i; } } } return -1; }, createDropIndicator: function(){ this.dropIndicator = document.createElement("div"); with(this.dropIndicator.style){ position = "absolute"; zIndex = 999; if(this.vertical){ borderLeftWidth = "1px"; borderLeftColor = "black"; borderLeftStyle = "solid"; height = dojo.html.getBorderBox(this.domNode).height + "px"; top = dojo.html.getAbsolutePosition(this.domNode, true).y + "px"; }else{ borderTopWidth = "1px"; borderTopColor = "black"; borderTopStyle = "solid"; width = dojo.html.getBorderBox(this.domNode).width + "px"; left = dojo.html.getAbsolutePosition(this.domNode, true).x + "px"; } } }, onDragMove: function(e, dragObjects){ var i = this._getNodeUnderMouse(e); if(!this.dropIndicator){ this.createDropIndicator(); } var gravity = this.vertical ? dojo.html.gravity.WEST : dojo.html.gravity.NORTH; var hide = false; if(i < 0){ if(this.childBoxes.length){ var before = (dojo.html.gravity(this.childBoxes[0].node, e) & gravity); if(before){ hide = true; } }else{ var before = true; } }else{ var child = this.childBoxes[i]; var before = (dojo.html.gravity(child.node, e) & gravity); if(child.node === dragObjects[0].dragSource.domNode){ hide = true; }else{ var currentPosChild = before ? (i>0?this.childBoxes[i-1]:child) : (i<this.childBoxes.length-1?this.childBoxes[i+1]:child); if(currentPosChild.node === dragObjects[0].dragSource.domNode){ hide = true; } } } if(hide){ this.dropIndicator.style.display="none"; return; }else{ this.dropIndicator.style.display=""; } this.placeIndicator(e, dragObjects, i, before); if(!dojo.html.hasParent(this.dropIndicator)) { dojo.body().appendChild(this.dropIndicator); } }, /** * Position the horizontal line that indicates "insert between these two items" */ placeIndicator: function(e, dragObjects, boxIndex, before) { var targetProperty = this.vertical ? "left" : "top"; var child; if(boxIndex < 0){ if(this.childBoxes.length){ child = before ? this.childBoxes[0] : this.childBoxes[this.childBoxes.length - 1]; }else{ this.dropIndicator.style[targetProperty] = dojo.html.getAbsolutePosition(this.domNode, true)[this.vertical?"x":"y"] + "px"; } }else{ child = this.childBoxes[boxIndex]; } if(child){ this.dropIndicator.style[targetProperty] = (before ? child[targetProperty] : child[this.vertical?"right":"bottom"]) + "px"; if(this.vertical){ this.dropIndicator.style.height = child.height + "px"; this.dropIndicator.style.top = child.top + "px"; }else{ this.dropIndicator.style.width = child.width + "px"; this.dropIndicator.style.left = child.left + "px"; } } }, onDragOut: function(e) { if(this.dropIndicator) { dojo.html.removeNode(this.dropIndicator); delete this.dropIndicator; } }, /** * Inserts the DragObject as a child of this node relative to the * position of the mouse. * * @return true if the DragObject was inserted, false otherwise */ onDrop: function(e){ this.onDragOut(e); var i = this._getNodeUnderMouse(e); var gravity = this.vertical ? dojo.html.gravity.WEST : dojo.html.gravity.NORTH; if(i < 0){ if(this.childBoxes.length){ if(dojo.html.gravity(this.childBoxes[0].node, e) & gravity){ return this.insert(e, this.childBoxes[0].node, "before"); }else{ return this.insert(e, this.childBoxes[this.childBoxes.length-1].node, "after"); } } return this.insert(e, this.domNode, "append"); } var child = this.childBoxes[i]; if(dojo.html.gravity(child.node, e) & gravity){ return this.insert(e, child.node, "before"); }else{ return this.insert(e, child.node, "after"); } }, insert: function(e, refNode, position){ var node = e.dragObject.domNode; if(position == "before"){ return dojo.html.insertBefore(node, refNode); }else if(position == "after"){ return dojo.html.insertAfter(node, refNode); }else if(position == "append"){ refNode.appendChild(node); return true; } return false; } }, function(node, types){ if(arguments.length == 0){ return; } this.domNode = dojo.byId(node); dojo.dnd.DropTarget.call(this); if(types && dojo.lang.isString(types)) { types = [types]; } this.acceptedTypes = types || []; dojo.dnd.dragManager.registerDropTarget(this); } ); /** * TreeDrag* specialized on managing subtree drags * It selects nodes and visualises what's going on, * but delegates real actions upon tree to the controller * * This code is considered a part of controller */ dojo.provide("dojo.dnd.TreeDragAndDrop"); dojo.dnd.TreeDragSource = function(node, syncController, type, treeNode){ this.controller = syncController; this.treeNode = treeNode; dojo.dnd.HtmlDragSource.call(this, node, type); } dojo.inherits(dojo.dnd.TreeDragSource, dojo.dnd.HtmlDragSource); dojo.lang.extend(dojo.dnd.TreeDragSource, { onDragStart: function(){ /* extend adds functions to prototype */ var dragObject = dojo.dnd.HtmlDragSource.prototype.onDragStart.call(this); //dojo.debugShallow(dragObject) dragObject.treeNode = this.treeNode; dragObject.onDragStart = dojo.lang.hitch(dragObject, function(e) { /* save selection */ this.savedSelectedNode = this.treeNode.tree.selector.selectedNode; if (this.savedSelectedNode) { this.savedSelectedNode.unMarkSelected(); } var result = dojo.dnd.HtmlDragObject.prototype.onDragStart.apply(this, arguments); /* remove background grid from cloned object */ var cloneGrid = this.dragClone.getElementsByTagName('img'); for(var i=0; i<cloneGrid.length; i++) { cloneGrid.item(i).style.backgroundImage='url()'; } return result; }); dragObject.onDragEnd = function(e) { /* restore selection */ if (this.savedSelectedNode) { this.savedSelectedNode.markSelected(); } //dojo.debug(e.dragStatus); return dojo.dnd.HtmlDragObject.prototype.onDragEnd.apply(this, arguments); } //dojo.debug(dragObject.domNode.outerHTML) return dragObject; }, onDragEnd: function(e){ var res = dojo.dnd.HtmlDragSource.prototype.onDragEnd.call(this, e); return res; } }); // ....................................... dojo.dnd.TreeDropTarget = function(domNode, controller, type, treeNode){ this.treeNode = treeNode; this.controller = controller; // I will sync-ly process drops dojo.dnd.HtmlDropTarget.apply(this, [domNode, type]); } dojo.inherits(dojo.dnd.TreeDropTarget, dojo.dnd.HtmlDropTarget); dojo.lang.extend(dojo.dnd.TreeDropTarget, { autoExpandDelay: 1500, autoExpandTimer: null, position: null, indicatorStyle: "2px black solid", showIndicator: function(position) { // do not change style too often, cause of blinking possible if (this.position == position) { return; } //dojo.debug(position) this.hideIndicator(); this.position = position; if (position == "before") { this.treeNode.labelNode.style.borderTop = this.indicatorStyle; } else if (position == "after") { this.treeNode.labelNode.style.borderBottom = this.indicatorStyle; } else if (position == "onto") { this.treeNode.markSelected(); } }, hideIndicator: function() { this.treeNode.labelNode.style.borderBottom=""; this.treeNode.labelNode.style.borderTop=""; this.treeNode.unMarkSelected(); this.position = null; }, // is the target possibly ok ? // This function is run on dragOver, but drop possibility is also determined by position over node // that's why acceptsWithPosition is called // doesnt take index into account ( can change while moving mouse w/o changing target ) /** * Coarse (tree-level) access check. * We can't determine real accepts status w/o position */ onDragOver: function(e){ //dojo.debug("onDragOver for "+e); var accepts = dojo.dnd.HtmlDropTarget.prototype.onDragOver.apply(this, arguments); //dojo.debug("TreeDropTarget.onDragOver accepts:"+accepts) if (accepts && this.treeNode.isFolder && !this.treeNode.isExpanded) { this.setAutoExpandTimer(); } return accepts; }, /* Parent.onDragOver calls this function to get accepts status */ accepts: function(dragObjects) { var accepts = dojo.dnd.HtmlDropTarget.prototype.accepts.apply(this, arguments); if (!accepts) return false; var sourceTreeNode = dragObjects[0].treeNode; if (dojo.lang.isUndefined(sourceTreeNode) || !sourceTreeNode || !sourceTreeNode.isTreeNode) { dojo.raise("Source is not TreeNode or not found"); } if (sourceTreeNode === this.treeNode) return false; return true; }, setAutoExpandTimer: function() { // set up autoexpand timer var _this = this; var autoExpand = function () { if (dojo.dnd.dragManager.currentDropTarget === _this) { _this.controller.expand(_this.treeNode); } } this.autoExpandTimer = dojo.lang.setTimeout(autoExpand, _this.autoExpandDelay); }, getDNDMode: function() { return this.treeNode.tree.DNDMode; }, getAcceptPosition: function(e, sourceTreeNode) { var DNDMode = this.getDNDMode(); if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO && // check if ONTO is allowed localy !( !this.treeNode.actionIsDisabled(dojo.widget.TreeNode.prototype.actions.ADDCHILD) // check dynamically cause may change w/o regeneration of dropTarget && sourceTreeNode.parent !== this.treeNode && this.controller.canMove(sourceTreeNode, this.treeNode) ) ) { // disable ONTO if can't move DNDMode &= ~dojo.widget.Tree.prototype.DNDModes.ONTO; } var position = this.getPosition(e, DNDMode); //dojo.debug(DNDMode & +" : "+position); // if onto is here => it was allowed before, no accept check is needed if (position=="onto" || (!this.isAdjacentNode(sourceTreeNode, position) && this.controller.canMove(sourceTreeNode, this.treeNode.parent) ) ) { return position; } else { return false; } }, onDragOut: function(e) { this.clearAutoExpandTimer(); this.hideIndicator(); }, clearAutoExpandTimer: function() { if (this.autoExpandTimer) { clearTimeout(this.autoExpandTimer); this.autoExpandTimer = null; } }, onDragMove: function(e, dragObjects){ var sourceTreeNode = dragObjects[0].treeNode; var position = this.getAcceptPosition(e, sourceTreeNode); if (position) { this.showIndicator(position); } }, isAdjacentNode: function(sourceNode, position) { if (sourceNode === this.treeNode) return true; if (sourceNode.getNextSibling() === this.treeNode && position=="before") return true; if (sourceNode.getPreviousSibling() === this.treeNode && position=="after") return true; return false; }, /* get DNDMode and see which position e fits */ getPosition: function(e, DNDMode) { var node = dojo.byId(this.treeNode.labelNode); var mousey = e.pageY || e.clientY + dojo.body().scrollTop; var nodey = dojo.html.getAbsolutePosition(node).y; var height = dojo.html.getBorderBox(node).height; var relY = mousey - nodey; var p = relY / height; var position = ""; // "" <=> forbidden if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO && DNDMode & dojo.widget.Tree.prototype.DNDModes.BETWEEN) { if (p<=0.3) { position = "before"; } else if (p<=0.7) { position = "onto"; } else { position = "after"; } } else if (DNDMode & dojo.widget.Tree.prototype.DNDModes.BETWEEN) { if (p<=0.5) { position = "before"; } else { position = "after"; } } else if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO) { position = "onto"; } return position; }, getTargetParentIndex: function(sourceTreeNode, position) { var index = position == "before" ? this.treeNode.getParentIndex() : this.treeNode.getParentIndex()+1; if (this.treeNode.parent === sourceTreeNode.parent && this.treeNode.getParentIndex() > sourceTreeNode.getParentIndex()) { index--; // dragging a node is different for simple move bacause of before-after issues } return index; }, onDrop: function(e){ // onDragOut will clean position var position = this.position; //dojo.debug(position); this.onDragOut(e); var sourceTreeNode = e.dragObject.treeNode; if (!dojo.lang.isObject(sourceTreeNode)) { dojo.raise("TreeNode not found in dragObject") } if (position == "onto") { return this.controller.move(sourceTreeNode, this.treeNode, 0); } else { var index = this.getTargetParentIndex(sourceTreeNode, position); return this.controller.move(sourceTreeNode, this.treeNode.parent, index); } //dojo.debug('drop2'); } }); dojo.dnd.TreeDNDController = function(treeController) { // I use this controller to perform actions this.treeController = treeController; this.dragSources = {}; this.dropTargets = {}; } dojo.lang.extend(dojo.dnd.TreeDNDController, { listenTree: function(tree) { //dojo.debug("Listen tree "+tree); dojo.event.topic.subscribe(tree.eventNames.createDOMNode, this, "onCreateDOMNode"); dojo.event.topic.subscribe(tree.eventNames.moveFrom, this, "onMoveFrom"); dojo.event.topic.subscribe(tree.eventNames.moveTo, this, "onMoveTo"); dojo.event.topic.subscribe(tree.eventNames.addChild, this, "onAddChild"); dojo.event.topic.subscribe(tree.eventNames.removeNode, this, "onRemoveNode"); dojo.event.topic.subscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy"); }, unlistenTree: function(tree) { //dojo.debug("Listen tree "+tree); dojo.event.topic.unsubscribe(tree.eventNames.createDOMNode, this, "onCreateDOMNode"); dojo.event.topic.unsubscribe(tree.eventNames.moveFrom, this, "onMoveFrom"); dojo.event.topic.unsubscribe(tree.eventNames.moveTo, this, "onMoveTo"); dojo.event.topic.unsubscribe(tree.eventNames.addChild, this, "onAddChild"); dojo.event.topic.unsubscribe(tree.eventNames.removeNode, this, "onRemoveNode"); dojo.event.topic.unsubscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy"); }, onTreeDestroy: function(message) { this.unlistenTree(message.source); // I'm not widget so don't use destroy() call and dieWithTree }, onCreateDOMNode: function(message) { this.registerDNDNode(message.source); }, onAddChild: function(message) { this.registerDNDNode(message.child); }, onMoveFrom: function(message) { var _this = this; dojo.lang.forEach( message.child.getDescendants(), function(node) { _this.unregisterDNDNode(node); } ); }, onMoveTo: function(message) { var _this = this; dojo.lang.forEach( message.child.getDescendants(), function(node) { _this.registerDNDNode(node); } ); }, /** * Controller(node model) creates DNDNodes because it passes itself to node for synchroneous drops processing * I can't process DnD with events cause an event can't return result success/false */ registerDNDNode: function(node) { if (!node.tree.DNDMode) return; //dojo.debug("registerDNDNode "+node); /* I drag label, not domNode, because large domNodes are very slow to copy and large to drag */ var source = null; var target = null; if (!node.actionIsDisabled(node.actions.MOVE)) { //dojo.debug("reg source") var source = new dojo.dnd.TreeDragSource(node.labelNode, this, node.tree.widgetId, node); this.dragSources[node.widgetId] = source; } var target = new dojo.dnd.TreeDropTarget(node.labelNode, this.treeController, node.tree.DNDAcceptTypes, node); this.dropTargets[node.widgetId] = target; }, unregisterDNDNode: function(node) { if (this.dragSources[node.widgetId]) { dojo.dnd.dragManager.unregisterDragSource(this.dragSources[node.widgetId]); delete this.dragSources[node.widgetId]; } if (this.dropTargets[node.widgetId]) { dojo.dnd.dragManager.unregisterDropTarget(this.dropTargets[node.widgetId]); delete this.dropTargets[node.widgetId]; } } }); dojo.provide("dojo.widget.TreeBasicController"); dojo.widget.defineWidget("dojo.widget.TreeBasicController", dojo.widget.HtmlWidget, { widgetType: "TreeBasicController", DNDController: "", dieWithTree: false, initialize: function(args, frag){ /* no DND by default for compatibility */ if (this.DNDController == "create") { this.DNDController = new dojo.dnd.TreeDNDController(this); } }, /** * Binds controller to all tree events */ listenTree: function(tree) { //dojo.debug("Event "+tree.eventNames.treeClick); dojo.event.topic.subscribe(tree.eventNames.createDOMNode, this, "onCreateDOMNode"); dojo.event.topic.subscribe(tree.eventNames.treeClick, this, "onTreeClick"); dojo.event.topic.subscribe(tree.eventNames.treeCreate, this, "onTreeCreate"); dojo.event.topic.subscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy"); if (this.DNDController) { this.DNDController.listenTree(tree); } }, unlistenTree: function(tree) { dojo.event.topic.unsubscribe(tree.eventNames.createDOMNode, this, "onCreateDOMNode"); dojo.event.topic.unsubscribe(tree.eventNames.treeClick, this, "onTreeClick"); dojo.event.topic.unsubscribe(tree.eventNames.treeCreate, this, "onTreeCreate"); dojo.event.topic.unsubscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy"); }, onTreeDestroy: function(message) { var tree = message.source; this.unlistenTree(tree); if (this.dieWithTree) { //alert("Killing myself "+this.widgetId); this.destroy(); //dojo.debug("done"); } }, onCreateDOMNode: function(message) { var node = message.source; if (node.expandLevel > 0) { this.expandToLevel(node, node.expandLevel); } }, // perform actions-initializers for tree onTreeCreate: function(message) { var tree = message.source; var _this = this; if (tree.expandLevel) { dojo.lang.forEach(tree.children, function(child) { _this.expandToLevel(child, tree.expandLevel-1) } ); } }, expandToLevel: function(node, level) { if (level == 0) return; var children = node.children; var _this = this; var handler = function(node, expandLevel) { this.node = node; this.expandLevel = expandLevel; // recursively expand opened node this.process = function() { //dojo.debug("Process "+node+" level "+level); for(var i=0; i<this.node.children.length; i++) { var child = node.children[i]; _this.expandToLevel(child, this.expandLevel); } }; } var h = new handler(node, level-1); this.expand(node, false, h, h.process); }, onTreeClick: function(message){ var node = message.source; if(node.isLocked()) { return false; } if (node.isExpanded){ this.collapse(node); } else { this.expand(node); } }, expand: function(node, sync, callObj, callFunc) { node.expand(); if (callFunc) callFunc.apply(callObj, [node]); }, collapse: function(node) { node.collapse(); }, // =============================== move ============================ /** * Checks whether it is ok to change parent of child to newParent * May incur type checks etc * * It should check only hierarchical possibility w/o index, etc * because in onDragOver event for Between DND mode we can't calculate index at once on onDragOVer. * index changes as client moves mouse up-down over the node */ canMove: function(child, newParent){ if (child.actionIsDisabled(child.actions.MOVE)) { return false; } // if we move under same parent then no matter if ADDCHILD disabled for him // but if we move to NEW parent then check if action is disabled for him // also covers case for newParent being a non-folder in strict mode etc if (child.parent !== newParent && newParent.actionIsDisabled(newParent.actions.ADDCHILD)) { return false; } // Can't move parent under child. check whether new parent is child of "child". var node = newParent; while(node.isTreeNode) { //dojo.debugShallow(node.title) if (node === child) { // parent of newParent is child return false; } node = node.parent; } return true; }, move: function(child, newParent, index) { /* move sourceTreeNode to new parent */ if (!this.canMove(child, newParent)) { return false; } var result = this.doMove(child, newParent, index); if (!result) return result; if (newParent.isTreeNode) { this.expand(newParent); } return result; }, doMove: function(child, newParent, index) { child.tree.move(child, newParent, index); return true; }, // =============================== removeNode ============================ canRemoveNode: function(child) { if (child.actionIsDisabled(child.actions.REMOVE)) { return false; } return true; }, removeNode: function(node, callObj, callFunc) { if (!this.canRemoveNode(node)) { return false; } return this.doRemoveNode(node, callObj, callFunc); }, doRemoveNode: function(node, callObj, callFunc) { node.tree.removeNode(node); if (callFunc) { callFunc.apply(dojo.lang.isUndefined(callObj) ? this : callObj, [node]); } }, // ----------------------------------------------------------------------------- // Create node stuff // ----------------------------------------------------------------------------- canCreateChild: function(parent, index, data) { if (parent.actionIsDisabled(parent.actions.ADDCHILD)) return false; return true; }, /* send data to server and add child from server */ /* data may contain an almost ready child, or anything else, suggested to server */ /*in RPC controllers server responds with child data to be inserted */ createChild: function(parent, index, data, callObj, callFunc) { if (!this.canCreateChild(parent, index, data)) { return false; } return this.doCreateChild.apply(this, arguments); }, doCreateChild: function(parent, index, data, callObj, callFunc) { var widgetType = data.widgetType ? data.widgetType : "TreeNode"; var newChild = dojo.widget.createWidget(widgetType, data); parent.addChild(newChild, index); this.expand(parent); if (callFunc) { callFunc.apply(callObj, [newChild]); } return newChild; } }); dojo.provide("dojo.widget.TreeCommon"); // for dojo.widget.manager dojo.declare( "dojo.widget.TreeCommon", null, { listenTreeEvents: [], listenedTrees: {}, /** * evaluates to false => skip unlistening nodes * provided => use it */ listenNodeFilter: null, listenTree: function(tree) { //dojo.debug("listenTree in "+this+" tree "+tree); var _this = this; if (this.listenedTrees[tree.widgetId]) { return; // already listening } dojo.lang.forEach(this.listenTreeEvents, function(event) { var eventHandler = "on" + event.charAt(0).toUpperCase() + event.substr(1); //dojo.debug("subscribe: event "+tree.eventNames[event]+" widget "+_this+" handler "+eventHandler); dojo.event.topic.subscribe(tree.eventNames[event], _this, eventHandler); }); var filter; if (this.listenNodeFilter) { this.processDescendants(tree, this.listenNodeFilter, this.listenNode, true); } /** * remember that I listen to this tree. No unbinding/binding/deselection * needed when transfer between listened trees */ this.listenedTrees[tree.widgetId] = true; }, // interface functions listenNode: function() {}, unlistenNode: function() {}, unlistenTree: function(tree, nodeFilter) { var _this = this; if (!this.listenedTrees[tree.widgetId]) { return; } dojo.lang.forEach(this.listenTreeEvents, function(event) { var eventHandler = "on" + event.charAt(0).toUpperCase() + event.substr(1); dojo.event.topic.unsubscribe(tree.eventNames[event], _this, eventHandler); }); if (this.listenNodeFilter) { this.processDescendants(tree, this.listenNodeFilter, this.unlistenNode, true); } delete this.listenedTrees[tree.widgetId]; }, /** * check condition for node.domNode -> .. -> any node chain */ checkPathCondition: function(domElement, condition) { while (domElement && !domElement.widgetId) { if (condition.call(null, domElement)) { return true; } domElement = domElement.parentNode; } return false; }, /** * get node widget id by its descendant dom node */ domElement2TreeNode: function(domElement) { while (domElement && !domElement.widgetId) { domElement = domElement.parentNode; } if (!domElement) { return null; } var widget = dojo.widget.byId(domElement.widgetId); if (!widget.isTreeNode) { return null; } return widget; }, /** * it is here, not in Widget, because mostly tree needs it */ processDescendants: function(elem, filter, func, skipFirst) { var _this = this; if (!skipFirst) { if (!filter.call(_this,elem)) { return; } func.call(_this,elem); } var stack = [elem]; while (elem = stack.pop()) { dojo.lang.forEach(elem.children, function(elem) { if (filter.call(_this, elem)) { func.call(_this, elem); stack.push(elem); } }); } } }); dojo.provide("dojo.widget.TreeSelectorV3"); dojo.widget.defineWidget( "dojo.widget.TreeSelectorV3", [dojo.widget.HtmlWidget, dojo.widget.TreeCommon], function() { this.eventNames = {}; this.listenedTrees = {}; this.selectedNodes = []; this.lastClicked = {} }, { // TODO: add multiselect listenTreeEvents: ["afterTreeCreate","afterCollapse","afterChangeTree", "afterDetach", "beforeTreeDestroy"], listenNodeFilter: function(elem) { return elem instanceof dojo.widget.Widget}, allowedMulti: true, /** * if time between clicks < dblselectTimeout => its dblselect */ dblselectTimeout: 300, eventNamesDefault: { select : "select", deselect : "deselect", dblselect: "dblselect" // select already selected node.. Edit or whatever }, onAfterTreeCreate: function(message) { var tree = message.source; dojo.event.browser.addListener(tree.domNode, "onclick", dojo.lang.hitch(this, this.onTreeClick)); if (dojo.render.html.ie) { dojo.event.browser.addListener(tree.domNode, "ondblclick", dojo.lang.hitch(this, this.onTreeDblClick)); } dojo.event.browser.addListener(tree.domNode, "onKey", dojo.lang.hitch(this, this.onKey)); }, onKey: function(e) { if (!e.key || e.ctrkKey || e.altKey) { return; } switch(e.key) { case e.KEY_ENTER: var node = this.domElement2TreeNode(e.target); if (node) { this.processNode(node, e); } } }, onAfterChangeTree: function(message) { if (!message.oldTree && message.node.selected) { this.select(message.node); } if (!message.newTree || !this.listenedTrees[message.newTree.widgetId]) { // moving from our trfee to new one that we don't listen if (this.selectedNode && message.node.children) { this.deselectIfAncestorMatch(message.node); } } }, initialize: function(args) { for(var name in this.eventNamesDefault) { if (dojo.lang.isUndefined(this.eventNames[name])) { this.eventNames[name] = this.widgetId+"/"+this.eventNamesDefault[name]; } } }, onBeforeTreeDestroy: function(message) { this.unlistenTree(message.source); }, // deselect node if ancestor is collapsed onAfterCollapse: function(message) { this.deselectIfAncestorMatch(message.source); }, // IE will throw select -> dblselect. Need to transform to select->select onTreeDblClick: function(event) { this.onTreeClick(event); }, checkSpecialEvent: function(event) { return event.shiftKey || event.ctrlKey; }, onTreeClick: function(event) { var node = this.domElement2TreeNode(event.target); if (!node) { return; } var checkLabelClick = function(domElement) { return domElement === node.labelNode; } if (this.checkPathCondition(event.target, checkLabelClick)) { this.processNode(node, event); } }, /** * press on selected with ctrl => deselect it * press on selected w/o ctrl => dblselect it and deselect all other * * press on unselected with ctrl => add it to selection * * event may be both mouse & keyboard enter */ processNode: function(node, event) { if (node.actionIsDisabled(node.actions.SELECT)) { return; } //dojo.debug("click "+node+ "special "+this.checkSpecialEvent(event)); if (dojo.lang.inArray(this.selectedNodes, node)) { if(this.checkSpecialEvent(event)){ // If the node is currently selected, and they select it again while holding // down a meta key, it deselects it this.deselect(node); return; } var _this = this; var i=0; var selectedNode; /* remove all nodes from selection excepts this one */ while(this.selectedNodes.length > i) { selectedNode = this.selectedNodes[i]; if (selectedNode !== node) { //dojo.debug("Deselect "+selectedNode); this.deselect(selectedNode); continue; } i++; // skip the doubleclicked node } /* lastClicked.node may be undefined if node was selected(before) programmatically */ var wasJustClicked = this.checkRecentClick(node) eventName = wasJustClicked ? this.eventNames.dblselect : this.eventNames.select; if (wasJustClicked) { eventName = this.eventNames.dblselect; /* after dblselect, next select is usual select */ this.forgetLastClicked(); } else { eventName = this.eventNames.select; this.setLastClicked(node) } dojo.event.topic.publish(eventName, { node: node }); return; } /* if unselected node.. */ this.deselectIfNoMulti(event); //dojo.debug("select"); this.setLastClicked(node); this.select(node); }, forgetLastClicked: function() { this.lastClicked = {} }, setLastClicked: function(node) { this.lastClicked.date = new Date(); this.lastClicked.node = node; }, checkRecentClick: function(node) { var diff = new Date() - this.lastClicked.date; //dojo.debug(new Date()) //dojo.debug("check old "+this.lastClicked.node+" now "+(new Date())+" diff "+diff) if (this.lastClicked.node && diff < this.dblselectTimeout) { return true; } else { return false; } }, // deselect all if no meta key or disallowed deselectIfNoMulti: function(event) { if (!this.checkSpecialEvent(event) || !this.allowedMulti) { //dojo.debug("deselect All"); this.deselectAll(); } }, deselectIfAncestorMatch: function(ancestor) { /* deselect all nodes with this ancestor */ var _this = this; dojo.lang.forEach(this.selectedNodes, function(node) { var selectedNode = node; node = node.parent while (node && node.isTreeNode) { //dojo.debug("ancestor try "+node); if (node === ancestor) { _this.deselect(selectedNode); return; } node = node.parent; } }); }, onAfterDetach: function(message) { this.deselectIfAncestorMatch(message.child); }, select: function(node) { var index = dojo.lang.find(this.selectedNodes, node, true); if (index >=0 ) { return; // already selected } //dojo.debug("select "+node); this.selectedNodes.push(node); dojo.event.topic.publish(this.eventNames.select, {node: node} ); }, deselect: function(node){ var index = dojo.lang.find(this.selectedNodes, node, true); if (index < 0) { //dojo.debug("not selected"); return; // not selected } //dojo.debug("deselect "+node); //dojo.debug((new Error()).stack); this.selectedNodes.splice(index, 1); dojo.event.topic.publish(this.eventNames.deselect, {node: node} ); //dojo.debug("deselect"); }, deselectAll: function() { //dojo.debug("deselect all "+this.selectedNodes); while (this.selectedNodes.length) { this.deselect(this.selectedNodes[0]); } } }); dojo.provide("dojo.widget.TreeEmphasizeOnSelect"); // selector extension to emphasize node dojo.widget.defineWidget( "dojo.widget.TreeEmphasizeOnSelect", dojo.widget.HtmlWidget, { selector: "", initialize: function() { this.selector = dojo.widget.byId(this.selector); dojo.event.topic.subscribe(this.selector.eventNames.select, this, "onSelect"); dojo.event.topic.subscribe(this.selector.eventNames.deselect, this, "onDeselect"); }, onSelect: function(message) { message.node.viewEmphasize() }, onDeselect: function(message) { message.node.viewUnemphasize() } }); dojo.provide("dojo.widget.PopupContainer"); dojo.declare( "dojo.widget.PopupContainerBase", null, function(){ this.queueOnAnimationFinish = []; }, { // summary: // PopupContainerBase is the mixin class which provide popup behaviors: // it can open in a given position x,y or around a given node. // In addition, it handles animation and IE bleed through workaround. // description: // This class can not be used standalone: it should be mixed-in to a // dojo.widget.HtmlWidget. Use PopupContainer instead if you want a // a standalone popup widget // isShowingNow: Boolean: whether this popup is shown isShowingNow: false, // currentSubpopup: Widget: the shown sub popup if any currentSubpopup: null, // beginZIndex: Integer: the minimal popup zIndex beginZIndex: 1000, // parentPopup: Widget: parent popup widget parentPopup: null, // parent: Widget: the widget that caused me to be displayed; the logical parent. parent: null, // popupIndex: Integer: level of sub popup popupIndex: 0, // aroundBox: dojo.html.boxSizing: which bounding box to use for open aroundNode. By default use BORDER box of the aroundNode aroundBox: dojo.html.boxSizing.BORDER_BOX, // openedForWindow: Object: in which window the open() is triggered openedForWindow: null, processKey: function(/*Event*/evt){ // summary: key event handler return false; }, applyPopupBasicStyle: function(){ // summary: apply necessary css rules to the top domNode // description: // this function should be called in sub class where a custom // templateString/templateStringPath is used (see Tooltip widget) with(this.domNode.style){ display = 'none'; position = 'absolute'; } }, aboutToShow: function() { // summary: connect to this stub to modify the content of the popup }, open: function(/*Integer*/x, /*Integer*/y, /*DomNode*/parent, /*Object*/explodeSrc, /*String?*/orient, /*Array?*/padding){ // summary: // Open the popup at position (x,y), relative to dojo.body() // Or open(node, parent, explodeSrc, aroundOrient) to open // around node if (this.isShowingNow){ return; } // if I click right button and menu is opened, then it gets 2 commands: close -> open // so close enables animation and next "open" is put to queue to occur at new location if(this.animationInProgress){ this.queueOnAnimationFinish.push(this.open, arguments); return; } this.aboutToShow(); var around = false, node, aroundOrient; if(typeof x == 'object'){ node = x; aroundOrient = explodeSrc; explodeSrc = parent; parent = y; around = true; } // save this so that the focus can be returned this.parent = parent; // for unknown reasons even if the domNode is attached to the body in postCreate(), // it's not attached here, so have to attach it here. dojo.body().appendChild(this.domNode); // if explodeSrc isn't specified then explode from my parent widget explodeSrc = explodeSrc || parent["domNode"] || []; //keep track of parent popup to decided whether this is a top level popup var parentPopup = null; this.isTopLevel = true; while(parent){ if(parent !== this && (parent.setOpenedSubpopup != undefined && parent.applyPopupBasicStyle != undefined)){ parentPopup = parent; this.isTopLevel = false; parentPopup.setOpenedSubpopup(this); break; } parent = parent.parent; } this.parentPopup = parentPopup; this.popupIndex = parentPopup ? parentPopup.popupIndex + 1 : 1; if(this.isTopLevel){ var button = dojo.html.isNode(explodeSrc) ? explodeSrc : null; dojo.widget.PopupManager.opened(this, button); } //Store the current selection and restore it before the action for a menu item //is executed. This is required as clicking on an menu item deselects current selection if(this.isTopLevel && !dojo.withGlobal(this.openedForWindow||dojo.global(), dojo.html.selection.isCollapsed)){ this._bookmark = dojo.withGlobal(this.openedForWindow||dojo.global(), dojo.html.selection.getBookmark); }else{ this._bookmark = null; } //convert explodeSrc from format [x, y] to //{left: x, top: y, width: 0, height: 0} which is the new //format required by dojo.html.toCoordinateObject if(explodeSrc instanceof Array){ explodeSrc = {left: explodeSrc[0], top: explodeSrc[1], width: 0, height: 0}; } // display temporarily, and move into position, then hide again with(this.domNode.style){ display=""; zIndex = this.beginZIndex + this.popupIndex; } if(around){ this.move(node, padding, aroundOrient); }else{ this.move(x, y, padding, orient); } this.domNode.style.display="none"; this.explodeSrc = explodeSrc; // then use the user defined method to display it this.show(); this.isShowingNow = true; }, // TODOC: move(node, padding, aroundOrient) how to do this? move: function(/*Int*/x, /*Int*/y, /*Integer?*/padding, /*String?*/orient){ // summary: calculate where to place the popup var around = (typeof x == "object"); if(around){ var aroundOrient=padding; var node=x; padding=y; if(!aroundOrient){ //By default, attempt to open above the aroundNode, or below aroundOrient = {'BL': 'TL', 'TL': 'BL'}; } dojo.html.placeOnScreenAroundElement(this.domNode, node, padding, this.aroundBox, aroundOrient); }else{ if(!orient){ orient = 'TL,TR,BL,BR';} dojo.html.placeOnScreen(this.domNode, x, y, padding, true, orient); } }, close: function(/*Boolean?*/force){ // summary: hide the popup if(force){ this.domNode.style.display="none"; } // If we are in the process of opening the menu and we are asked to close it if(this.animationInProgress){ this.queueOnAnimationFinish.push(this.close, []); return; } this.closeSubpopup(force); this.hide(); if(this.bgIframe){ this.bgIframe.hide(); this.bgIframe.size({left: 0, top: 0, width: 0, height: 0}); } if(this.isTopLevel){ dojo.widget.PopupManager.closed(this); } this.isShowingNow = false; // return focus to the widget that opened the menu if(this.parent){ setTimeout( dojo.lang.hitch(this, function(){ try{ if(this.parent['focus']){ this.parent.focus(); }else{ this.parent.domNode.focus(); } }catch(e){dojo.debug("No idea how to focus to parent", e);} } ), 10 ); } //do not need to restore if current selection is not empty //(use keyboard to select a menu item) if(this._bookmark && dojo.withGlobal(this.openedForWindow||dojo.global(), dojo.html.selection.isCollapsed)){ if(this.openedForWindow){ this.openedForWindow.focus() } try{ dojo.withGlobal(this.openedForWindow||dojo.global(), "moveToBookmark", dojo.html.selection, [this._bookmark]); }catch(e){ /*squelch IE internal error, see http://trac.dojotoolkit.org/ticket/1984 */ } } this._bookmark = null; }, closeAll: function(/*Boolean?*/force){ // summary: hide all popups including sub ones if (this.parentPopup){ this.parentPopup.closeAll(force); }else{ this.close(force); } }, setOpenedSubpopup: function(/*Widget*/popup) { // summary: used by sub popup to set currentSubpopup in the parent popup this.currentSubpopup = popup; }, closeSubpopup: function(/*Boolean?*/force) { // summary: close opened sub popup if(this.currentSubpopup == null){ return; } this.currentSubpopup.close(force); this.currentSubpopup = null; }, onShow: function() { dojo.widget.PopupContainer.superclass.onShow.apply(this, arguments); // With some animation (wipe), after close, the size of the domnode is 0 // and next time when shown, the open() function can not determine // the correct place to popup, so we store the opened size here and // set it after close (in function onHide()) this.openedSize={w: this.domNode.style.width, h: this.domNode.style.height}; // prevent IE bleed through if(dojo.render.html.ie){ if(!this.bgIframe){ this.bgIframe = new dojo.html.BackgroundIframe(); this.bgIframe.setZIndex(this.domNode); } this.bgIframe.size(this.domNode); this.bgIframe.show(); } this.processQueue(); }, processQueue: function() { // summary: do events from queue if (!this.queueOnAnimationFinish.length) return; var func = this.queueOnAnimationFinish.shift(); var args = this.queueOnAnimationFinish.shift(); func.apply(this, args); }, onHide: function() { dojo.widget.HtmlWidget.prototype.onHide.call(this); //restore size of the domnode, see comment in //function onShow() if(this.openedSize){ with(this.domNode.style){ width=this.openedSize.w; height=this.openedSize.h; } } this.processQueue(); } }); dojo.widget.defineWidget( "dojo.widget.PopupContainer", [dojo.widget.HtmlWidget, dojo.widget.PopupContainerBase], { // summary: dojo.widget.PopupContainer is the widget version of dojo.widget.PopupContainerBase isContainer: true, fillInTemplate: function(){ this.applyPopupBasicStyle(); dojo.widget.PopupContainer.superclass.fillInTemplate.apply(this, arguments); } }); dojo.widget.PopupManager = new function(){ // summary: // the popup manager makes sure we don't have several popups // open at once. the root popup in an opening sequence calls // opened(). when a root menu closes it calls closed(). then // everything works. lovely. this.currentMenu = null; this.currentButton = null; // button that opened current menu (if any) this.currentFocusMenu = null; // the (sub)menu which receives key events this.focusNode = null; this.registeredWindows = []; this.registerWin = function(/*Window*/win){ // summary: register a window so that when clicks/scroll in it, the popup can be closed automatically if(!win.__PopupManagerRegistered) { dojo.event.connect(win.document, 'onmousedown', this, 'onClick'); dojo.event.connect(win, "onscroll", this, "onClick"); dojo.event.connect(win.document, "onkey", this, 'onKey'); win.__PopupManagerRegistered = true; this.registeredWindows.push(win); } }; /* */ this.registerAllWindows = function(/*Window*/targetWindow){ // summary: // This function register all the iframes and the top window, // so that whereever the user clicks in the page, the popup // menu will be closed // In case you add an iframe after onload event, please call // dojo.widget.PopupManager.registerWin manually //starting from window.top, clicking everywhere in this page //should close popup menus if(!targetWindow) { //see comment below targetWindow = dojo.html.getDocumentWindow(window.top && window.top.document || window.document); } this.registerWin(targetWindow); for (var i = 0; i < targetWindow.frames.length; i++){ try{ //do not remove dojo.html.getDocumentWindow, see comment in it var win = dojo.html.getDocumentWindow(targetWindow.frames[i].document); if(win){ this.registerAllWindows(win); } }catch(e){ /* squelch error for cross domain iframes */ } } }; this.unRegisterWin = function(/*Window*/win){ // summary: remove listeners on the registered window if(win.__PopupManagerRegistered) { dojo.event.disconnect(win.document, 'onmousedown', this, 'onClick'); dojo.event.disconnect(win, "onscroll", this, "onClick"); dojo.event.disconnect(win.document, "onkey", this, 'onKey'); win.__PopupManagerRegistered = false; } }; this.unRegisterAllWindows = function(){ // summary: remove listeners on all the registered windows for(var i=0;i<this.registeredWindows.length;++i){ this.unRegisterWin(this.registeredWindows[i]); } this.registeredWindows = []; }; dojo.addOnLoad(this, "registerAllWindows"); dojo.addOnUnload(this, "unRegisterAllWindows"); this.closed = function(/*Widget*/menu){ // summary: notify the manager that menu is closed if (this.currentMenu == menu){ this.currentMenu = null; this.currentButton = null; this.currentFocusMenu = null; } }; this.opened = function(/*Widget*/menu, /*DomNode*/button){ // summary: sets the current opened popup if (menu == this.currentMenu){ return; } if (this.currentMenu){ this.currentMenu.close(); } this.currentMenu = menu; this.currentFocusMenu = menu; this.currentButton = button; }; this.setFocusedMenu = function(/*Widget*/menu){ // summary: // Set the current focused popup, This is used by popups which supports keyboard navigation this.currentFocusMenu = menu; }; this.onKey = function(/*Event*/e){ if (!e.key) { return; } if(!this.currentMenu || !this.currentMenu.isShowingNow){ return; } // loop from child menu up ancestor chain, ending at button that spawned the menu var m = this.currentFocusMenu; while (m){ if(m.processKey(e)){ e.preventDefault(); e.stopPropagation(); break; } m = m.parentPopup || m.parentMenu; } }, this.onClick = function(/*Event*/e){ if (!this.currentMenu){ return; } var scrolloffset = dojo.html.getScroll().offset; // starting from the base menu, perform a hit test // and exit when one succeeds var m = this.currentMenu; while (m){ if(dojo.html.overElement(m.domNode, e) || dojo.html.isDescendantOf(e.target, m.domNode)){ return; } m = m.currentSubpopup; } // Also, if user clicked the button that opened this menu, then // that button will send the menu a close() command, so this code // shouldn't try to close the menu. Closing twice messes up animation. if (this.currentButton && dojo.html.overElement(this.currentButton, e)){ return; } // the click didn't fall within the open menu tree // so close it this.currentMenu.closeAll(true); }; } dojo.provide("dojo.widget.Tooltip"); dojo.widget.defineWidget( "dojo.widget.Tooltip", [dojo.widget.ContentPane, dojo.widget.PopupContainerBase], { // summary // Pops up a tooltip (a help message) when you hover over a node // caption: String // Text to display in the tooltip. // Can also be specified as innerHTML (when creating the widget from markup). caption: "", // showDelay: Integer // Number of milliseconds to wait after hovering over the object, before // the tooltip is displayed. showDelay: 500, // hideDelay: Integer // Number of milliseconds to wait after moving mouse off of the object (or // off of the tooltip itself), before erasing the tooltip hideDelay: 100, // connectId: String // Id of domNode to attach the tooltip to. // (When user hovers over specified dom node, the tooltip will appear.) connectId: "", templateCssString:".dojoTooltip {\r\n\tborder: solid black 1px;\r\n\tbackground: beige;\r\n\tcolor: black;\r\n\tposition: absolute;\r\n\tfont-size: small;\r\n\tpadding: 2px 2px 2px 2px;\r\n\tz-index: 10;\r\n\tdisplay: block;\r\n}\r\n",templateCssPath: dojo.uri.moduleUri("dojo.widget", "templates/TooltipTemplate.css"), fillInTemplate: function(args, frag){ if(this.caption != ""){ this.domNode.appendChild(document.createTextNode(this.caption)); } this._connectNode = dojo.byId(this.connectId); dojo.widget.Tooltip.superclass.fillInTemplate.call(this, args, frag); this.addOnLoad(this, "_loadedContent"); dojo.html.addClass(this.domNode, "dojoTooltip"); //copy style from input node to output node var source = this.getFragNodeRef(frag); dojo.html.copyStyle(this.domNode, source); //apply the necessary css rules to the node so that it can popup this.applyPopupBasicStyle(); }, postCreate: function(args, frag){ dojo.event.connect(this._connectNode, "onmouseover", this, "_onMouseOver"); dojo.widget.Tooltip.superclass.postCreate.call(this, args, frag); }, _onMouseOver: function(e){ this._mouse = {x: e.pageX, y: e.pageY}; // Start tracking mouse movements, so we know when to cancel timers or erase the tooltip if(!this._tracking){ dojo.event.connect(document.documentElement, "onmousemove", this, "_onMouseMove"); this._tracking=true; } this._onHover(e); }, _onMouseMove: function(e) { this._mouse = {x: e.pageX, y: e.pageY}; if(dojo.html.overElement(this._connectNode, e) || dojo.html.overElement(this.domNode, e)){ this._onHover(e); } else { // mouse has been moved off the element/tooltip // note: can't use onMouseOut to detect this because the "explode" effect causes // spurious onMouseOut events (due to interference from outline), w/out corresponding _onMouseOver this._onUnHover(e); } }, _onHover: function(e) { if(this._hover){ return; } this._hover=true; // If the tooltip has been scheduled to be erased, cancel that timer // since we are hovering over element/tooltip again if(this._hideTimer) { clearTimeout(this._hideTimer); delete this._hideTimer; } // If tooltip not showing yet then set a timer to show it shortly if(!this.isShowingNow && !this._showTimer){ this._showTimer = setTimeout(dojo.lang.hitch(this, "open"), this.showDelay); } }, _onUnHover: function(e){ if(!this._hover){ return; } this._hover=false; if(this._showTimer){ clearTimeout(this._showTimer); delete this._showTimer; } if(this.isShowingNow && !this._hideTimer){ this._hideTimer = setTimeout(dojo.lang.hitch(this, "close"), this.hideDelay); } // If we aren't showing the tooltip, then we can stop tracking the mouse now; // otherwise must track the mouse until tooltip disappears if(!this.isShowingNow){ dojo.event.disconnect(document.documentElement, "onmousemove", this, "_onMouseMove"); this._tracking=false; } }, open: function() { // summary: display the tooltip; usually not called directly. if (this.isShowingNow) { return; } dojo.widget.PopupContainerBase.prototype.open.call(this, this._mouse.x, this._mouse.y, null, [this._mouse.x, this._mouse.y], "TL,TR,BL,BR", [10,15]); }, close: function() { // summary: hide the tooltip; usually not called directly. if (this.isShowingNow) { if ( this._showTimer ) { clearTimeout(this._showTimer); delete this._showTimer; } if ( this._hideTimer ) { clearTimeout(this._hideTimer); delete this._hideTimer; } dojo.event.disconnect(document.documentElement, "onmousemove", this, "_onMouseMove"); this._tracking=false; dojo.widget.PopupContainerBase.prototype.close.call(this); } }, _position: function(){ this.move(this._mouse.x, this._mouse.y, [10,15], "TL,TR,BL,BR"); }, _loadedContent: function(){ if(this.isShowingNow){ // the tooltip has changed size due to downloaded contents, so reposition it this._position(); } }, checkSize: function(){ // Override checkSize() in HtmlWidget. // checkSize() is called when the user has resized the browser window, // but that doesn't affect this widget (or this widget's children) // so it can be safely ignored }, uninitialize: function(){ this.close(); dojo.event.disconnect(this._connectNode, "onmouseover", this, "_onMouseOver"); } } ); dojo.provide("dojo.widget.DropdownContainer"); dojo.widget.defineWidget( "dojo.widget.DropdownContainer", dojo.widget.HtmlWidget, { // summary: // provides an input box and a button for a dropdown. // In subclass, the dropdown can be specified. // inputWidth: String: width of the input box inputWidth: "7em", // id: String: id of this widget id: "", // inputId: String: id of the input box inputId: "", // inputName: String: name of the input box inputName: "", // iconURL: dojo.uri.Uri: icon for the dropdown button iconURL: dojo.uri.moduleUri("dojo.widget", "templates/images/combo_box_arrow.png"), // copyClass: // should we use the class properties on the source node instead // of our own styles? copyClasses: false, // iconAlt: dojo.uri.Uri: alt text for the dropdown button icon iconAlt: "", // containerToggle: String: toggle property of the dropdown containerToggle: "plain", // containerToggleDuration: Integer: toggle duration property of the dropdown containerToggleDuration: 150, templateString: '<span style="white-space:nowrap"><input type="hidden" name="" value="" dojoAttachPoint="valueNode" /><input name="" type="text" value="" style="vertical-align:middle;" dojoAttachPoint="inputNode" autocomplete="off" /> <img src="${this.iconURL}" alt="${this.iconAlt}" dojoAttachEvent="onclick:onIconClick" dojoAttachPoint="buttonNode" style="vertical-align:middle; cursor:pointer; cursor:hand" /></span>', templateCssPath: "", isContainer: true, attachTemplateNodes: function(){ // summary: use attachTemplateNodes to specify containerNode, as fillInTemplate is too late for this dojo.widget.DropdownContainer.superclass.attachTemplateNodes.apply(this, arguments); this.popup = dojo.widget.createWidget("PopupContainer", {toggle: this.containerToggle, toggleDuration: this.containerToggleDuration}); this.containerNode = this.popup.domNode; }, fillInTemplate: function(args, frag){ this.domNode.appendChild(this.popup.domNode); if(this.id) { this.domNode.id = this.id; } if(this.inputId){ this.inputNode.id = this.inputId; } if(this.inputName){ this.inputNode.name = this.inputName; } this.inputNode.style.width = this.inputWidth; this.inputNode.disabled = this.disabled; if(this.copyClasses){ this.inputNode.style = ""; this.inputNode.className = this.getFragNodeRef(frag).className; } dojo.event.connect(this.inputNode, "onchange", this, "onInputChange"); }, onIconClick: function(/*Event*/ evt){ if(this.disabled) return; if(!this.popup.isShowingNow){ this.popup.open(this.inputNode, this, this.buttonNode); }else{ this.popup.close(); } }, hideContainer: function(){ // summary: hide the dropdown if(this.popup.isShowingNow){ this.popup.close(); } }, onInputChange: function(){ // summary: signal for changes in the input box }, enable: function() { // summary: enable this widget to accept user input this.inputNode.disabled = false; dojo.widget.DropdownContainer.superclass.enable.apply(this, arguments); }, disable: function() { // summary: lock this widget so that the user can't change the value this.inputNode.disabled = true; dojo.widget.DropdownContainer.superclass.disable.apply(this, arguments); } } ); dojo.provide("dojo.date.common"); /* Supplementary Date Functions *******************************/ dojo.date.setDayOfYear = function(/*Date*/dateObject, /*Number*/dayOfYear){ // summary: sets dateObject according to day of the year (1..366) dateObject.setMonth(0); dateObject.setDate(dayOfYear); return dateObject; // Date } dojo.date.getDayOfYear = function(/*Date*/dateObject){ // summary: gets the day of the year as represented by dateObject var fullYear = dateObject.getFullYear(); var lastDayOfPrevYear = new Date(fullYear-1, 11, 31); return Math.floor((dateObject.getTime() - lastDayOfPrevYear.getTime()) / 86400000); // Number } dojo.date.setWeekOfYear = function(/*Date*/dateObject, /*Number*/week, /*Number*/firstDay){ if(arguments.length == 1){ firstDay = 0; } // Sunday dojo.unimplemented("dojo.date.setWeekOfYear"); } dojo.date.getWeekOfYear = function(/*Date*/dateObject, /*Number*/firstDay){ if(arguments.length == 1){ firstDay = 0; } // Sunday // work out the first day of the year corresponding to the week var firstDayOfYear = new Date(dateObject.getFullYear(), 0, 1); var day = firstDayOfYear.getDay(); firstDayOfYear.setDate(firstDayOfYear.getDate() - day + firstDay - (day > firstDay ? 7 : 0)); return Math.floor((dateObject.getTime() - firstDayOfYear.getTime()) / 604800000); } dojo.date.setIsoWeekOfYear = function(/*Date*/dateObject, /*Number*/week, /*Number*/firstDay){ // summary: unimplemented if (arguments.length == 1) { firstDay = 1; } // Monday dojo.unimplemented("dojo.date.setIsoWeekOfYear"); } dojo.date.getIsoWeekOfYear = function(/*Date*/dateObject, /*Number*/firstDay) { // summary: unimplemented if (arguments.length == 1) { firstDay = 1; } // Monday dojo.unimplemented("dojo.date.getIsoWeekOfYear"); } /* Informational Functions **************************/ //DEPRECATED: These timezone arrays will be deprecated in 0.5 dojo.date.shortTimezones = ["IDLW", "BET", "HST", "MART", "AKST", "PST", "MST", "CST", "EST", "AST", "NFT", "BST", "FST", "AT", "GMT", "CET", "EET", "MSK", "IRT", "GST", "AFT", "AGTT", "IST", "NPT", "ALMT", "MMT", "JT", "AWST", "JST", "ACST", "AEST", "LHST", "VUT", "NFT", "NZT", "CHAST", "PHOT", "LINT"]; dojo.date.timezoneOffsets = [-720, -660, -600, -570, -540, -480, -420, -360, -300, -240, -210, -180, -120, -60, 0, 60, 120, 180, 210, 240, 270, 300, 330, 345, 360, 390, 420, 480, 540, 570, 600, 630, 660, 690, 720, 765, 780, 840]; /* dojo.date.timezones = ["International Date Line West", "Bering Standard Time", "Hawaiian Standard Time", "Marquesas Time", "Alaska Standard Time", "Pacific Standard Time (USA)", "Mountain Standard Time", "Central Standard Time (USA)", "Eastern Standard Time (USA)", "Atlantic Standard Time", "Newfoundland Time", "Brazil Standard Time", "Fernando de Noronha Standard Time (Brazil)", "Azores Time", "Greenwich Mean Time", "Central Europe Time", "Eastern Europe Time", "Moscow Time", "Iran Standard Time", "Gulf Standard Time", "Afghanistan Time", "Aqtobe Time", "Indian Standard Time", "Nepal Time", "Almaty Time", "Myanmar Time", "Java Time", "Australian Western Standard Time", "Japan Standard Time", "Australian Central Standard Time", "Lord Hove Standard Time (Australia)", "Vanuata Time", "Norfolk Time (Australia)", "New Zealand Standard Time", "Chatham Standard Time (New Zealand)", "Phoenix Islands Time (Kribati)", "Line Islands Time (Kribati)"]; */ dojo.date.getDaysInMonth = function(/*Date*/dateObject){ // summary: returns the number of days in the month used by dateObject var month = dateObject.getMonth(); var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; if (month == 1 && dojo.date.isLeapYear(dateObject)) { return 29; } // Number else { return days[month]; } // Number } dojo.date.isLeapYear = function(/*Date*/dateObject){ // summary: // Determines if the year of the dateObject is a leap year // // description: // Leap years are years with an additional day YYYY-02-29, where the year // number is a multiple of four with the following exception: If a year // is a multiple of 100, then it is only a leap year if it is also a // multiple of 400. For example, 1900 was not a leap year, but 2000 is one. var year = dateObject.getFullYear(); return (year%400 == 0) ? true : (year%100 == 0) ? false : (year%4 == 0) ? true : false; // Boolean } // FIXME: This is not localized dojo.date.getTimezoneName = function(/*Date*/dateObject){ // summary: // Get the user's time zone as provided by the browser // // dateObject: needed because the timezone may vary with time (daylight savings) // // description: // Try to get time zone info from toString or toLocaleString // method of the Date object -- UTC offset is not a time zone. // See http://www.twinsun.com/tz/tz-link.htm // Note: results may be inconsistent across browsers. var str = dateObject.toString(); // Start looking in toString var tz = ''; // The result -- return empty string if nothing found var match; // First look for something in parentheses -- fast lookup, no regex var pos = str.indexOf('('); if (pos > -1) { pos++; tz = str.substring(pos, str.indexOf(')')); } // If at first you don't succeed ... else{ // If IE knows about the TZ, it appears before the year // Capital letters or slash before a 4-digit year // at the end of string var pat = /([A-Z\/]+) \d{4}$/; if((match = str.match(pat))) { tz = match[1]; } // Some browsers (e.g. Safari) glue the TZ on the end // of toLocaleString instead of putting it in toString else{ str = dateObject.toLocaleString(); // Capital letters or slash -- end of string, // after space pat = / ([A-Z\/]+)$/; if((match = str.match(pat))) { tz = match[1]; } } } // Make sure it doesn't somehow end up return AM or PM return tz == 'AM' || tz == 'PM' ? '' : tz; //String } //FIXME: not localized dojo.date.getOrdinal = function(dateObject){ // summary: returns the appropriate suffix (English only) for the day of the month, e.g. 'st' for 1, 'nd' for 2, etc.) var date = dateObject.getDate(); if(date%100 != 11 && date%10 == 1){ return "st"; } // String else if(date%100 != 12 && date%10 == 2){ return "nd"; } // String else if(date%100 != 13 && date%10 == 3){ return "rd"; } // String else{ return "th"; } // String } /* compare and add ******************/ dojo.date.compareTypes={ // summary // bitmask for comparison operations. DATE:1, TIME:2 }; dojo.date.compare=function(/* Date */ dateA, /* Date */ dateB, /* dojo.date.compareTypes */ options){ // summary // Compare two date objects by date, time, or both. Returns 0 if equal, positive if a > b, else negative. var dA=dateA; var dB=dateB||new Date(); var now=new Date(); //FIXME: shorten this code with(dojo.date.compareTypes){ var opt=options||(DATE|TIME); var d1=new Date( (opt&DATE)?dA.getFullYear():now.getFullYear(), (opt&DATE)?dA.getMonth():now.getMonth(), (opt&DATE)?dA.getDate():now.getDate(), (opt&TIME)?dA.getHours():0, (opt&TIME)?dA.getMinutes():0, (opt&TIME)?dA.getSeconds():0 ); var d2=new Date( (opt&DATE)?dB.getFullYear():now.getFullYear(), (opt&DATE)?dB.getMonth():now.getMonth(), (opt&DATE)?dB.getDate():now.getDate(), (opt&TIME)?dB.getHours():0, (opt&TIME)?dB.getMinutes():0, (opt&TIME)?dB.getSeconds():0 ); } if(d1.valueOf()>d2.valueOf()){ return 1; // int } if(d1.valueOf()<d2.valueOf()){ return -1; // int } return 0; // int } dojo.date.dateParts={ // summary // constants for use in dojo.date.add YEAR:0, MONTH:1, DAY:2, HOUR:3, MINUTE:4, SECOND:5, MILLISECOND:6, QUARTER:7, WEEK:8, WEEKDAY:9 }; dojo.date.add = function(/* Date */ dt, /* dojo.date.dateParts */ interv, /* int */ incr){ // summary: // Add to a Date in intervals of different size, from milliseconds to years // // dt: // A Javascript Date object to start with // // interv: // A constant representing the interval, e.g. YEAR, MONTH, DAY. See dojo.date.dateParts. // // incr: // How much to add to the date if(typeof dt == 'number'){dt = new Date(dt);} // Allow timestamps //FIXME: what's the reason behind this? incr = incr || 1; function fixOvershoot(){ if (sum.getDate() < dt.getDate()){ sum.setDate(0); } } var sum = new Date(dt); with(dojo.date.dateParts){ switch(interv){ case YEAR: sum.setFullYear(dt.getFullYear()+incr); // Keep increment/decrement from 2/29 out of March fixOvershoot(); break; case QUARTER: // Naive quarter is just three months incr*=3; // fallthrough... case MONTH: sum.setMonth(dt.getMonth()+incr); // Reset to last day of month if you overshoot fixOvershoot(); break; case WEEK: incr*=7; // fallthrough... case DAY: sum.setDate(dt.getDate() + incr); break; case WEEKDAY: //FIXME: assumes Saturday/Sunday weekend, but even this is not fixed. There are CLDR entries to localize this. var dat = dt.getDate(); var weeks = 0; var days = 0; var strt = 0; var trgt = 0; var adj = 0; // Divide the increment time span into weekspans plus leftover days // e.g., 8 days is one 5-day weekspan / and two leftover days // Can't have zero leftover days, so numbers divisible by 5 get // a days value of 5, and the remaining days make up the number of weeks var mod = incr % 5; if (mod == 0) { days = (incr > 0) ? 5 : -5; weeks = (incr > 0) ? ((incr-5)/5) : ((incr+5)/5); } else { days = mod; weeks = parseInt(incr/5); } // Get weekday value for orig date param strt = dt.getDay(); // Orig date is Sat / positive incrementer // Jump over Sun if (strt == 6 && incr > 0) { adj = 1; } // Orig date is Sun / negative incrementer // Jump back over Sat else if (strt == 0 && incr < 0) { adj = -1; } // Get weekday val for the new date trgt = (strt + days); // New date is on Sat or Sun if (trgt == 0 || trgt == 6) { adj = (incr > 0) ? 2 : -2; } // Increment by number of weeks plus leftover days plus // weekend adjustments sum.setDate(dat + (7*weeks) + days + adj); break; case HOUR: sum.setHours(sum.getHours()+incr); break; case MINUTE: sum.setMinutes(sum.getMinutes()+incr); break; case SECOND: sum.setSeconds(sum.getSeconds()+incr); break; case MILLISECOND: sum.setMilliseconds(sum.getMilliseconds()+incr); break; default: // Do nothing break; } } return sum; // Date }; dojo.date.diff = function(/* Date */ dtA, /* Date */ dtB, /* dojo.date.dateParts */ interv){ // summary: // Get the difference in a specific unit of time (e.g., number of months, weeks, // days, etc.) between two dates. // // dtA: // A Javascript Date object // // dtB: // A Javascript Date object // // interv: // A constant representing the interval, e.g. YEAR, MONTH, DAY. See dojo.date.dateParts. // Accept timestamp input if(typeof dtA == 'number'){dtA = new Date(dtA);} if(typeof dtB == 'number'){dtB = new Date(dtB);} var yeaDiff = dtB.getFullYear() - dtA.getFullYear(); var monDiff = (dtB.getMonth() - dtA.getMonth()) + (yeaDiff * 12); var msDiff = dtB.getTime() - dtA.getTime(); // Millisecs var secDiff = msDiff/1000; var minDiff = secDiff/60; var houDiff = minDiff/60; var dayDiff = houDiff/24; var weeDiff = dayDiff/7; var delta = 0; // Integer return value with(dojo.date.dateParts){ switch(interv){ case YEAR: delta = yeaDiff; break; case QUARTER: var mA = dtA.getMonth(); var mB = dtB.getMonth(); // Figure out which quarter the months are in var qA = Math.floor(mA/3) + 1; var qB = Math.floor(mB/3) + 1; // Add quarters for any year difference between the dates qB += (yeaDiff * 4); delta = qB - qA; break; case MONTH: delta = monDiff; break; case WEEK: // Truncate instead of rounding // Don't use Math.floor -- value may be negative delta = parseInt(weeDiff); break; case DAY: delta = dayDiff; break; case WEEKDAY: var days = Math.round(dayDiff); var weeks = parseInt(days/7); var mod = days % 7; // Even number of weeks if (mod == 0) { days = weeks*5; } // Weeks plus spare change (< 7 days) else { var adj = 0; var aDay = dtA.getDay(); var bDay = dtB.getDay(); weeks = parseInt(days/7); mod = days % 7; // Mark the date advanced by the number of // round weeks (may be zero) var dtMark = new Date(dtA); dtMark.setDate(dtMark.getDate()+(weeks*7)); var dayMark = dtMark.getDay(); // Spare change days -- 6 or less // ---------- // Positive diff if (dayDiff > 0) { switch (true) { // Range starts on Sat case aDay == 6: adj = -1; break; // Range starts on Sun case aDay == 0: adj = 0; break; // Range ends on Sat case bDay == 6: adj = -1; break; // Range ends on Sun case bDay == 0: adj = -2; break; // Range contains weekend case (dayMark + mod) > 5: adj = -2; break; default: // Do nothing break; } } // Negative diff else if (dayDiff < 0) { switch (true) { // Range starts on Sat case aDay == 6: adj = 0; break; // Range starts on Sun case aDay == 0: adj = 1; break; // Range ends on Sat case bDay == 6: adj = 2; break; // Range ends on Sun case bDay == 0: adj = 1; break; // Range contains weekend case (dayMark + mod) < 0: adj = 2; break; default: // Do nothing break; } } days += adj; days -= (weeks*2); } delta = days; break; case HOUR: delta = houDiff; break; case MINUTE: delta = minDiff; break; case SECOND: delta = secDiff; break; case MILLISECOND: delta = msDiff; break; default: // Do nothing break; } } // Round for fractional values and DST leaps return Math.round(delta); // Number (integer) }; dojo.provide("dojo.date.supplemental"); dojo.date.getFirstDayOfWeek = function(/*String?*/locale){ // summary: Returns a zero-based index for first day of the week // description: // Returns a zero-based index for first day of the week, as used by the local (Gregorian) calendar. // e.g. Sunday (returns 0), or Monday (returns 1) // from http://www.unicode.org/cldr/data/common/supplemental/supplementalData.xml:supplementalData/weekData/firstDay var firstDay = {/*default is 1=Monday*/ mv:5, ae:6,af:6,bh:6,dj:6,dz:6,eg:6,er:6,et:6,iq:6,ir:6,jo:6,ke:6,kw:6,lb:6,ly:6,ma:6,om:6,qa:6,sa:6, sd:6,so:6,tn:6,ye:6, as:0,au:0,az:0,bw:0,ca:0,cn:0,fo:0,ge:0,gl:0,gu:0,hk:0,ie:0,il:0,is:0,jm:0,jp:0,kg:0,kr:0,la:0, mh:0,mo:0,mp:0,mt:0,nz:0,ph:0,pk:0,sg:0,th:0,tt:0,tw:0,um:0,us:0,uz:0,vi:0,za:0,zw:0, et:0,mw:0,ng:0,tj:0, gb:0, sy:4 }; locale = dojo.hostenv.normalizeLocale(locale); var country = locale.split("-")[1]; var dow = firstDay[country]; return (typeof dow == 'undefined') ? 1 : dow; /*Number*/ }; dojo.date.getWeekend = function(/*String?*/locale){ // summary: Returns a hash containing the start and end days of the weekend // description: // Returns a hash containing the start and end days of the weekend according to local custom using locale, // or by default in the user's locale. // e.g. {start:6, end:0} // from http://www.unicode.org/cldr/data/common/supplemental/supplementalData.xml:supplementalData/weekData/weekend{Start,End} var weekendStart = {/*default is 6=Saturday*/ eg:5,il:5,sy:5, 'in':0, ae:4,bh:4,dz:4,iq:4,jo:4,kw:4,lb:4,ly:4,ma:4,om:4,qa:4,sa:4,sd:4,tn:4,ye:4 }; var weekendEnd = {/*default is 0=Sunday*/ ae:5,bh:5,dz:5,iq:5,jo:5,kw:5,lb:5,ly:5,ma:5,om:5,qa:5,sa:5,sd:5,tn:5,ye:5,af:5,ir:5, eg:6,il:6,sy:6 }; locale = dojo.hostenv.normalizeLocale(locale); var country = locale.split("-")[1]; var start = weekendStart[country]; var end = weekendEnd[country]; if(typeof start == 'undefined'){start=6;} if(typeof end == 'undefined'){end=0;} return {start:start, end:end}; /*Object {start,end}*/ }; dojo.date.isWeekend = function(/*Date?*/dateObj, /*String?*/locale){ // summary: // Determines if the date falls on a weekend, according to local custom. var weekend = dojo.date.getWeekend(locale); var day = (dateObj || new Date()).getDay(); if(weekend.end<weekend.start){ weekend.end+=7; if(day<weekend.start){ day+=7; } } return day >= weekend.start && day <= weekend.end; // Boolean }; dojo.provide("dojo.i18n.common"); dojo.i18n.getLocalization = function(/*String*/packageName, /*String*/bundleName, /*String?*/locale){ // summary: // Returns an Object containing the localization for a given resource bundle // in a package, matching the specified locale. // // description: // Returns a hash containing name/value pairs in its prototypesuch that values can be easily overridden. // Throws an exception if the bundle is not found. // Bundle must have already been loaded by dojo.requireLocalization() or by a build optimization step. // // packageName: package which is associated with this resource // bundleName: the base filename of the resource bundle (without the ".js" suffix) // locale: the variant to load (optional). By default, the locale defined by the // host environment: dojo.locale dojo.hostenv.preloadLocalizations(); locale = dojo.hostenv.normalizeLocale(locale); // look for nearest locale match var elements = locale.split('-'); var module = [packageName,"nls",bundleName].join('.'); var bundle = dojo.hostenv.findModule(module, true); var localization; for(var i = elements.length; i > 0; i--){ var loc = elements.slice(0, i).join('_'); if(bundle[loc]){ localization = bundle[loc]; break; } } if(!localization){ localization = bundle.ROOT; } // make a singleton prototype so that the caller won't accidentally change the values globally if(localization){ var clazz = function(){}; clazz.prototype = localization; return new clazz(); // Object } dojo.raise("Bundle not found: " + bundleName + " in " + packageName+" , locale=" + locale); }; dojo.i18n.isLTR = function(/*String?*/locale){ // summary: // Is the language read left-to-right? Most exceptions are for middle eastern languages. // // locale: a string representing the locale. By default, the locale defined by the // host environment: dojo.locale var lang = dojo.hostenv.normalizeLocale(locale).split('-')[0]; var RTL = {ar:true,fa:true,he:true,ur:true,yi:true}; return !RTL[lang]; // Boolean }; dojo.provide("dojo.date.format"); // Load the bundles containing localization information for // names and formats //NOTE: Everything in this module assumes Gregorian calendars. // Other calendars will be implemented in separate modules. (function(){ dojo.date.format = function(/*Date*/dateObject, /*Object?*/options){ // // summary: // Format a Date object as a String, using locale-specific settings. // // description: // Create a string from a Date object using a known localized pattern. // By default, this method formats both date and time from dateObject. // Formatting patterns are chosen appropriate to the locale. Different // formatting lengths may be chosen, with "full" used by default. // Custom patterns may be used or registered with translations using // the addCustomBundle method. // Formatting patterns are implemented using the syntax described at // http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns // // dateObject: // the date and/or time to be formatted. If a time only is formatted, // the values in the year, month, and day fields are irrelevant. The // opposite is true when formatting only dates. // // options: object {selector: string, formatLength: string, datePattern: string, timePattern: string, locale: string} // selector- choice of timeOnly,dateOnly (default: date and time) // formatLength- choice of long, short, medium or full (plus any custom additions). Defaults to 'full' // datePattern,timePattern- override pattern with this string // am,pm- override strings for am/pm in times // locale- override the locale used to determine formatting rules // if(typeof options == "string"){ dojo.deprecated("dojo.date.format", "To format dates with POSIX-style strings, please use dojo.date.strftime instead", "0.5"); return dojo.date.strftime(dateObject, options); } // Format a pattern without literals function formatPattern(dateObject, pattern){ return pattern.replace(/([a-z])\1*/ig, function(match){ var s; var c = match.charAt(0); var l = match.length; var pad; var widthList = ["abbr", "wide", "narrow"]; switch(c){ case 'G': if(l>3){dojo.unimplemented("Era format not implemented");} s = info.eras[dateObject.getFullYear() < 0 ? 1 : 0]; break; case 'y': s = dateObject.getFullYear(); switch(l){ case 1: break; case 2: s = String(s).substr(-2); break; default: pad = true; } break; case 'Q': case 'q': s = Math.ceil((dateObject.getMonth()+1)/3); switch(l){ case 1: case 2: pad = true; break; case 3: case 4: dojo.unimplemented("Quarter format not implemented"); } break; case 'M': case 'L': var m = dateObject.getMonth(); var width; switch(l){ case 1: case 2: s = m+1; pad = true; break; case 3: case 4: case 5: width = widthList[l-3]; break; } if(width){ var type = (c == "L") ? "standalone" : "format"; var prop = ["months",type,width].join("-"); s = info[prop][m]; } break; case 'w': var firstDay = 0; s = dojo.date.getWeekOfYear(dateObject, firstDay); pad = true; break; case 'd': s = dateObject.getDate(); pad = true; break; case 'D': s = dojo.date.getDayOfYear(dateObject); pad = true; break; case 'E': case 'e': case 'c': // REVIEW: don't see this in the spec? var d = dateObject.getDay(); var width; switch(l){ case 1: case 2: if(c == 'e'){ var first = dojo.date.getFirstDayOfWeek(options.locale); d = (d-first+7)%7; } if(c != 'c'){ s = d+1; pad = true; break; } // else fallthrough... case 3: case 4: case 5: width = widthList[l-3]; break; } if(width){ var type = (c == "c") ? "standalone" : "format"; var prop = ["days",type,width].join("-"); s = info[prop][d]; } break; case 'a': var timePeriod = (dateObject.getHours() < 12) ? 'am' : 'pm'; s = info[timePeriod]; break; case 'h': case 'H': case 'K': case 'k': var h = dateObject.getHours(); // strange choices in the date format make it impossible to write this succinctly switch (c) { case 'h': // 1-12 s = (h % 12) || 12; break; case 'H': // 0-23 s = h; break; case 'K': // 0-11 s = (h % 12); break; case 'k': // 1-24 s = h || 24; break; } pad = true; break; case 'm': s = dateObject.getMinutes(); pad = true; break; case 's': s = dateObject.getSeconds(); pad = true; break; case 'S': s = Math.round(dateObject.getMilliseconds() * Math.pow(10, l-3)); break; case 'v': // FIXME: don't know what this is. seems to be same as z? case 'z': // We only have one timezone to offer; the one from the browser s = dojo.date.getTimezoneName(dateObject); if(s){break;} l=4; // fallthrough... use GMT if tz not available case 'Z': var offset = dateObject.getTimezoneOffset(); var tz = [ (offset<=0 ? "+" : "-"), dojo.string.pad(Math.floor(Math.abs(offset)/60), 2), dojo.string.pad(Math.abs(offset)% 60, 2) ]; if(l==4){ tz.splice(0, 0, "GMT"); tz.splice(3, 0, ":"); } s = tz.join(""); break; case 'Y': case 'u': case 'W': case 'F': case 'g': case 'A': dojo.debug(match+" modifier not yet implemented"); s = "?"; break; default: dojo.raise("dojo.date.format: invalid pattern char: "+pattern); } if(pad){ s = dojo.string.pad(s, l); } return s; }); } options = options || {}; var locale = dojo.hostenv.normalizeLocale(options.locale); var formatLength = options.formatLength || 'full'; var info = dojo.date._getGregorianBundle(locale); var str = []; var sauce = dojo.lang.curry(this, formatPattern, dateObject); if(options.selector != "timeOnly"){ var datePattern = options.datePattern || info["dateFormat-"+formatLength]; if(datePattern){str.push(_processPattern(datePattern, sauce));} } if(options.selector != "dateOnly"){ var timePattern = options.timePattern || info["timeFormat-"+formatLength]; if(timePattern){str.push(_processPattern(timePattern, sauce));} } var result = str.join(" "); //TODO: use locale-specific pattern to assemble date + time return result; /*String*/ }; dojo.date.parse = function(/*String*/value, /*Object?*/options){ // // summary: // Convert a properly formatted string to a primitive Date object, // using locale-specific settings. // // description: // Create a Date object from a string using a known localized pattern. // By default, this method parses looking for both date and time in the string. // Formatting patterns are chosen appropriate to the locale. Different // formatting lengths may be chosen, with "full" used by default. // Custom patterns may be used or registered with translations using // the addCustomBundle method. // Formatting patterns are implemented using the syntax described at // http://www.unicode.org/reports/tr35/#Date_Format_Patterns // // value: // A string representation of a date // // options: object {selector: string, formatLength: string, datePattern: string, timePattern: string, locale: string, strict: boolean} // selector- choice of timeOnly, dateOnly, dateTime (default: dateOnly) // formatLength- choice of long, short, medium or full (plus any custom additions). Defaults to 'full' // datePattern,timePattern- override pattern with this string // am,pm- override strings for am/pm in times // locale- override the locale used to determine formatting rules // strict- strict parsing, off by default // options = options || {}; var locale = dojo.hostenv.normalizeLocale(options.locale); var info = dojo.date._getGregorianBundle(locale); var formatLength = options.formatLength || 'full'; if(!options.selector){ options.selector = 'dateOnly'; } var datePattern = options.datePattern || info["dateFormat-" + formatLength]; var timePattern = options.timePattern || info["timeFormat-" + formatLength]; var pattern; if(options.selector == 'dateOnly'){ pattern = datePattern; } else if(options.selector == 'timeOnly'){ pattern = timePattern; }else if(options.selector == 'dateTime'){ pattern = datePattern + ' ' + timePattern; //TODO: use locale-specific pattern to assemble date + time }else{ var msg = "dojo.date.parse: Unknown selector param passed: '" + options.selector + "'."; msg += " Defaulting to date pattern."; dojo.debug(msg); pattern = datePattern; } var groups = []; var dateREString = _processPattern(pattern, dojo.lang.curry(this, _buildDateTimeRE, groups, info, options)); var dateRE = new RegExp("^" + dateREString + "$"); var match = dateRE.exec(value); if(!match){ return null; } var widthList = ['abbr', 'wide', 'narrow']; //1972 is a leap year. We want to avoid Feb 29 rolling over into Mar 1, //in the cases where the year is parsed after the month and day. var result = new Date(1972, 0); var expected = {}; for(var i=1; i<match.length; i++){ var grp=groups[i-1]; var l=grp.length; var v=match[i]; switch(grp.charAt(0)){ case 'y': if(l != 2){ //interpret year literally, so '5' would be 5 A.D. result.setFullYear(v); expected.year = v; }else{ if(v<100){ v = Number(v); //choose century to apply, according to a sliding window //of 80 years before and 20 years after present year var year = '' + new Date().getFullYear(); var century = year.substring(0, 2) * 100; var yearPart = Number(year.substring(2, 4)); var cutoff = Math.min(yearPart + 20, 99); var num = (v < cutoff) ? century + v : century - 100 + v; result.setFullYear(num); expected.year = num; }else{ //we expected 2 digits and got more... if(options.strict){ return null; } //interpret literally, so '150' would be 150 A.D. //also tolerate '1950', if 'yyyy' input passed to 'yy' format result.setFullYear(v); expected.year = v; } } break; case 'M': if (l>2) { if(!options.strict){ //Tolerate abbreviating period in month part v = v.replace(/\./g,''); //Case-insensitive v = v.toLowerCase(); } var months = info['months-format-' + widthList[l-3]].concat(); for (var j=0; j<months.length; j++){ if(!options.strict){ //Case-insensitive months[j] = months[j].toLowerCase(); } if(v == months[j]){ result.setMonth(j); expected.month = j; break; } } if(j==months.length){ dojo.debug("dojo.date.parse: Could not parse month name: '" + v + "'."); return null; } }else{ result.setMonth(v-1); expected.month = v-1; } break; case 'E': case 'e': if(!options.strict){ //Case-insensitive v = v.toLowerCase(); } var days = info['days-format-' + widthList[l-3]].concat(); for (var j=0; j<days.length; j++){ if(!options.strict){ //Case-insensitive days[j] = days[j].toLowerCase(); } if(v == days[j]){ //TODO: not sure what to actually do with this input, //in terms of setting something on the Date obj...? //without more context, can't affect the actual date break; } } if(j==days.length){ dojo.debug("dojo.date.parse: Could not parse weekday name: '" + v + "'."); return null; } break; case 'd': result.setDate(v); expected.date = v; break; case 'a': //am/pm var am = options.am || info.am; var pm = options.pm || info.pm; if(!options.strict){ v = v.replace(/\./g,'').toLowerCase(); am = am.replace(/\./g,'').toLowerCase(); pm = pm.replace(/\./g,'').toLowerCase(); } if(options.strict && v != am && v != pm){ dojo.debug("dojo.date.parse: Could not parse am/pm part."); return null; } var hours = result.getHours(); if(v == pm && hours < 12){ result.setHours(hours + 12); //e.g., 3pm -> 15 } else if(v == am && hours == 12){ result.setHours(0); //12am -> 0 } break; case 'K': //hour (1-24) if(v==24){v=0;} // fallthrough... case 'h': //hour (1-12) case 'H': //hour (0-23) case 'k': //hour (0-11) //TODO: strict bounds checking, padding if(v>23){ dojo.debug("dojo.date.parse: Illegal hours value"); return null; } //in the 12-hour case, adjusting for am/pm requires the 'a' part //which for now we will assume always comes after the 'h' part result.setHours(v); break; case 'm': //minutes result.setMinutes(v); break; case 's': //seconds result.setSeconds(v); break; case 'S': //milliseconds result.setMilliseconds(v); break; default: dojo.unimplemented("dojo.date.parse: unsupported pattern char=" + grp.charAt(0)); } } //validate parse date fields versus input date fields if(expected.year && result.getFullYear() != expected.year){ dojo.debug("Parsed year: '" + result.getFullYear() + "' did not match input year: '" + expected.year + "'."); return null; } if(expected.month && result.getMonth() != expected.month){ dojo.debug("Parsed month: '" + result.getMonth() + "' did not match input month: '" + expected.month + "'."); return null; } if(expected.date && result.getDate() != expected.date){ dojo.debug("Parsed day of month: '" + result.getDate() + "' did not match input day of month: '" + expected.date + "'."); return null; } //TODO: implement a getWeekday() method in order to test //validity of input strings containing 'EEE' or 'EEEE'... return result; /*Date*/ }; function _processPattern(pattern, applyPattern, applyLiteral, applyAll){ // Process a pattern with literals in it // Break up on single quotes, treat every other one as a literal, except '' which becomes ' var identity = function(x){return x;}; applyPattern = applyPattern || identity; applyLiteral = applyLiteral || identity; applyAll = applyAll || identity; //split on single quotes (which escape literals in date format strings) //but preserve escaped single quotes (e.g., o''clock) var chunks = pattern.match(/(''|[^'])+/g); var literal = false; for(var i=0; i<chunks.length; i++){ if(!chunks[i]){ chunks[i]=''; } else { chunks[i]=(literal ? applyLiteral : applyPattern)(chunks[i]); literal = !literal; } } return applyAll(chunks.join('')); } function _buildDateTimeRE(groups, info, options, pattern){ return pattern.replace(/([a-z])\1*/ig, function(match){ // Build a simple regexp without parenthesis, which would ruin the match list var s; var c = match.charAt(0); var l = match.length; switch(c){ case 'y': s = '\\d' + ((l==2) ? '{2,4}' : '+'); break; case 'M': s = (l>2) ? '\\S+' : '\\d{1,2}'; break; case 'd': s = '\\d{1,2}'; break; case 'E': s = '\\S+'; break; case 'h': case 'H': case 'K': case 'k': s = '\\d{1,2}'; break; case 'm': case 's': s = '[0-5]\\d'; break; case 'S': s = '\\d{1,3}'; break; case 'a': var am = options.am || info.am || 'AM'; var pm = options.pm || info.pm || 'PM'; if(options.strict){ s = am + '|' + pm; }else{ s = am; s += (am != am.toLowerCase()) ? '|' + am.toLowerCase() : ''; s += '|'; s += (pm != pm.toLowerCase()) ? pm + '|' + pm.toLowerCase() : pm; } break; default: dojo.unimplemented("parse of date format, pattern=" + pattern); } if(groups){ groups.push(match); } //FIXME: replace whitespace within final regexp with more flexible whitespace match instead? //tolerate whitespace return '\\s*(' + s + ')\\s*'; }); } })(); //TODO: try to common strftime and format code somehow? dojo.date.strftime = function(/*Date*/dateObject, /*String*/format, /*String?*/locale){ // // summary: // Formats the date object using the specifications of the POSIX strftime function // // description: // see <http://www.opengroup.org/onlinepubs/007908799/xsh/strftime.html> // zero pad var padChar = null; function _(s, n){ return dojo.string.pad(s, n || 2, padChar || "0"); } var info = dojo.date._getGregorianBundle(locale); function $(property){ switch (property){ case "a": // abbreviated weekday name according to the current locale return dojo.date.getDayShortName(dateObject, locale); case "A": // full weekday name according to the current locale return dojo.date.getDayName(dateObject, locale); case "b": case "h": // abbreviated month name according to the current locale return dojo.date.getMonthShortName(dateObject, locale); case "B": // full month name according to the current locale return dojo.date.getMonthName(dateObject, locale); case "c": // preferred date and time representation for the current // locale return dojo.date.format(dateObject, {locale: locale}); case "C": // century number (the year divided by 100 and truncated // to an integer, range 00 to 99) return _(Math.floor(dateObject.getFullYear()/100)); case "d": // day of the month as a decimal number (range 01 to 31) return _(dateObject.getDate()); case "D": // same as %m/%d/%y return $("m") + "/" + $("d") + "/" + $("y"); case "e": // day of the month as a decimal number, a single digit is // preceded by a space (range ' 1' to '31') if(padChar == null){ padChar = " "; } return _(dateObject.getDate()); case "f": // month as a decimal number, a single digit is // preceded by a space (range ' 1' to '12') if(padChar == null){ padChar = " "; } return _(dateObject.getMonth()+1); case "g": // like %G, but without the century. break; case "G": // The 4-digit year corresponding to the ISO week number // (see %V). This has the same format and value as %Y, // except that if the ISO week number belongs to the // previous or next year, that year is used instead. dojo.unimplemented("unimplemented modifier 'G'"); break; case "F": // same as %Y-%m-%d return $("Y") + "-" + $("m") + "-" + $("d"); case "H": // hour as a decimal number using a 24-hour clock (range // 00 to 23) return _(dateObject.getHours()); case "I": // hour as a decimal number using a 12-hour clock (range // 01 to 12) return _(dateObject.getHours() % 12 || 12); case "j": // day of the year as a decimal number (range 001 to 366) return _(dojo.date.getDayOfYear(dateObject), 3); case "k": // Hour as a decimal number using a 24-hour clock (range // 0 to 23 (space-padded)) if (padChar == null) { padChar = " "; } return _(dateObject.getHours()); case "l": // Hour as a decimal number using a 12-hour clock (range // 1 to 12 (space-padded)) if (padChar == null) { padChar = " "; } return _(dateObject.getHours() % 12 || 12); case "m": // month as a decimal number (range 01 to 12) return _(dateObject.getMonth() + 1); case "M": // minute as a decimal number return _(dateObject.getMinutes()); case "n": return "\n"; case "p": // either `am' or `pm' according to the given time value, // or the corresponding strings for the current locale return info[dateObject.getHours() < 12 ? "am" : "pm"]; case "r": // time in a.m. and p.m. notation return $("I") + ":" + $("M") + ":" + $("S") + " " + $("p"); case "R": // time in 24 hour notation return $("H") + ":" + $("M"); case "S": // second as a decimal number return _(dateObject.getSeconds()); case "t": return "\t"; case "T": // current time, equal to %H:%M:%S return $("H") + ":" + $("M") + ":" + $("S"); case "u": // weekday as a decimal number [1,7], with 1 representing // Monday return String(dateObject.getDay() || 7); case "U": // week number of the current year as a decimal number, // starting with the first Sunday as the first day of the // first week return _(dojo.date.getWeekOfYear(dateObject)); case "V": // week number of the year (Monday as the first day of the // week) as a decimal number [01,53]. If the week containing // 1 January has four or more days in the new year, then it // is considered week 1. Otherwise, it is the last week of // the previous year, and the next week is week 1. return _(dojo.date.getIsoWeekOfYear(dateObject)); case "W": // week number of the current year as a decimal number, // starting with the first Monday as the first day of the // first week return _(dojo.date.getWeekOfYear(dateObject, 1)); case "w": // day of the week as a decimal, Sunday being 0 return String(dateObject.getDay()); case "x": // preferred date representation for the current locale // without the time return dojo.date.format(dateObject, {selector:'dateOnly', locale:locale}); case "X": // preferred time representation for the current locale // without the date return dojo.date.format(dateObject, {selector:'timeOnly', locale:locale}); case "y": // year as a decimal number without a century (range 00 to // 99) return _(dateObject.getFullYear()%100); case "Y": // year as a decimal number including the century return String(dateObject.getFullYear()); case "z": // time zone or name or abbreviation var timezoneOffset = dateObject.getTimezoneOffset(); return (timezoneOffset > 0 ? "-" : "+") + _(Math.floor(Math.abs(timezoneOffset)/60)) + ":" + _(Math.abs(timezoneOffset)%60); case "Z": // time zone or name or abbreviation return dojo.date.getTimezoneName(dateObject); case "%": return "%"; } } // parse the formatting string and construct the resulting string var string = ""; var i = 0; var index = 0; var switchCase = null; while ((index = format.indexOf("%", i)) != -1){ string += format.substring(i, index++); // inspect modifier flag switch (format.charAt(index++)) { case "_": // Pad a numeric result string with spaces. padChar = " "; break; case "-": // Do not pad a numeric result string. padChar = ""; break; case "0": // Pad a numeric result string with zeros. padChar = "0"; break; case "^": // Convert characters in result string to uppercase. switchCase = "upper"; break; case "*": // Convert characters in result string to lowercase switchCase = "lower"; break; case "#": // Swap the case of the result string. switchCase = "swap"; break; default: // no modifier flag so decrement the index padChar = null; index--; break; } // toggle case if a flag is set var property = $(format.charAt(index++)); switch (switchCase){ case "upper": property = property.toUpperCase(); break; case "lower": property = property.toLowerCase(); break; case "swap": // Upper to lower, and versey-vicea var compareString = property.toLowerCase(); var swapString = ''; var j = 0; var ch = ''; while (j < property.length){ ch = property.charAt(j); swapString += (ch == compareString.charAt(j)) ? ch.toUpperCase() : ch.toLowerCase(); j++; } property = swapString; break; default: break; } switchCase = null; string += property; i = index; } string += format.substring(i); return string; // String }; (function(){ var _customFormats = []; dojo.date.addCustomFormats = function(/*String*/packageName, /*String*/bundleName){ // // summary: // Add a reference to a bundle containing localized custom formats to be // used by date/time formatting and parsing routines. // // description: // The user may add custom localized formats where the bundle has properties following the // same naming convention used by dojo for the CLDR data: dateFormat-xxxx / timeFormat-xxxx // The pattern string should match the format used by the CLDR. // See dojo.date.format for details. // The resources must be loaded by dojo.requireLocalization() prior to use _customFormats.push({pkg:packageName,name:bundleName}); }; dojo.date._getGregorianBundle = function(/*String*/locale){ var gregorian = {}; dojo.lang.forEach(_customFormats, function(desc){ var bundle = dojo.i18n.getLocalization(desc.pkg, desc.name, locale); gregorian = dojo.lang.mixin(gregorian, bundle); }, this); return gregorian; /*Object*/ }; })(); dojo.date.addCustomFormats("dojo.i18n.calendar","gregorian"); dojo.date.addCustomFormats("dojo.i18n.calendar","gregorianExtras"); dojo.date.getNames = function(/*String*/item, /*String*/type, /*String?*/use, /*String?*/locale){ // // summary: // Used to get localized strings for day or month names. // // item: 'months' || 'days' // type: 'wide' || 'narrow' || 'abbr' (e.g. "Monday", "Mon", or "M" respectively, in English) // use: 'standAlone' || 'format' (default) // locale: override locale used to find the names var label; var lookup = dojo.date._getGregorianBundle(locale); var props = [item, use, type]; if(use == 'standAlone'){ label = lookup[props.join('-')]; } props[1] = 'format'; // return by copy so changes won't be made accidentally to the in-memory model return (label || lookup[props.join('-')]).concat(); /*Array*/ }; // Convenience methods dojo.date.getDayName = function(/*Date*/dateObject, /*String?*/locale){ // summary: gets the full localized day of the week corresponding to the date object return dojo.date.getNames('days', 'wide', 'format', locale)[dateObject.getDay()]; /*String*/ }; dojo.date.getDayShortName = function(/*Date*/dateObject, /*String?*/locale){ // summary: gets the abbreviated localized day of the week corresponding to the date object return dojo.date.getNames('days', 'abbr', 'format', locale)[dateObject.getDay()]; /*String*/ }; dojo.date.getMonthName = function(/*Date*/dateObject, /*String?*/locale){ // summary: gets the full localized month name corresponding to the date object return dojo.date.getNames('months', 'wide', 'format', locale)[dateObject.getMonth()]; /*String*/ }; dojo.date.getMonthShortName = function(/*Date*/dateObject, /*String?*/locale){ // summary: gets the abbreviated localized month name corresponding to the date object return dojo.date.getNames('months', 'abbr', 'format', locale)[dateObject.getMonth()]; /*String*/ }; //FIXME: not localized dojo.date.toRelativeString = function(/*Date*/dateObject){ // summary: // Returns an description in English of the date relative to the current date. Note: this is not localized yet. English only. // // description: Example returns: // - "1 minute ago" // - "4 minutes ago" // - "Yesterday" // - "2 days ago" var now = new Date(); var diff = (now - dateObject) / 1000; var end = " ago"; var future = false; if(diff < 0){ future = true; end = " from now"; diff = -diff; } if(diff < 60){ diff = Math.round(diff); return diff + " second" + (diff == 1 ? "" : "s") + end; } if(diff < 60*60){ diff = Math.round(diff/60); return diff + " minute" + (diff == 1 ? "" : "s") + end; } if(diff < 60*60*24){ diff = Math.round(diff/3600); return diff + " hour" + (diff == 1 ? "" : "s") + end; } if(diff < 60*60*24*7){ diff = Math.round(diff/(3600*24)); if(diff == 1){ return future ? "Tomorrow" : "Yesterday"; }else{ return diff + " days" + end; } } return dojo.date.format(dateObject); // String }; //FIXME: SQL methods can probably be moved to a different module without i18n deps dojo.date.toSql = function(/*Date*/dateObject, /*Boolean?*/noTime){ // summary: // Convert a Date to a SQL string // noTime: whether to ignore the time portion of the Date. Defaults to false. return dojo.date.strftime(dateObject, "%F" + !noTime ? " %T" : ""); // String }; dojo.date.fromSql = function(/*String*/sqlDate){ // summary: // Convert a SQL date string to a JavaScript Date object var parts = sqlDate.split(/[\- :]/g); while(parts.length < 6){ parts.push(0); } return new Date(parts[0], (parseInt(parts[1],10)-1), parts[2], parts[3], parts[4], parts[5]); // Date }; dojo.provide("dojo.date.serialize"); /* ISO 8601 Functions *********************/ dojo.date.setIso8601 = function(/*Date*/dateObject, /*String*/formattedString){ // summary: sets a Date object based on an ISO 8601 formatted string (uses date and time) var comps = (formattedString.indexOf("T") == -1) ? formattedString.split(" ") : formattedString.split("T"); dateObject = dojo.date.setIso8601Date(dateObject, comps[0]); if(comps.length == 2){ dateObject = dojo.date.setIso8601Time(dateObject, comps[1]); } return dateObject; /* Date or null */ }; dojo.date.fromIso8601 = function(/*String*/formattedString){ // summary: returns a Date object based on an ISO 8601 formatted string (uses date and time) return dojo.date.setIso8601(new Date(0, 0), formattedString); }; dojo.date.setIso8601Date = function(/*String*/dateObject, /*String*/formattedString){ // summary: sets a Date object based on an ISO 8601 formatted string (date only) var regexp = "^([0-9]{4})((-?([0-9]{2})(-?([0-9]{2}))?)|" + "(-?([0-9]{3}))|(-?W([0-9]{2})(-?([1-7]))?))?$"; var d = formattedString.match(new RegExp(regexp)); if(!d){ dojo.debug("invalid date string: " + formattedString); return null; // null } var year = d[1]; var month = d[4]; var date = d[6]; var dayofyear = d[8]; var week = d[10]; var dayofweek = d[12] ? d[12] : 1; dateObject.setFullYear(year); if(dayofyear){ dateObject.setMonth(0); dateObject.setDate(Number(dayofyear)); } else if(week){ dateObject.setMonth(0); dateObject.setDate(1); var gd = dateObject.getDay(); var day = gd ? gd : 7; var offset = Number(dayofweek) + (7 * Number(week)); if(day <= 4){ dateObject.setDate(offset + 1 - day); } else{ dateObject.setDate(offset + 8 - day); } } else{ if(month){ dateObject.setDate(1); dateObject.setMonth(month - 1); } if(date){ dateObject.setDate(date); } } return dateObject; // Date }; dojo.date.fromIso8601Date = function(/*String*/formattedString){ // summary: returns a Date object based on an ISO 8601 formatted string (date only) return dojo.date.setIso8601Date(new Date(0, 0), formattedString); }; dojo.date.setIso8601Time = function(/*Date*/dateObject, /*String*/formattedString){ // summary: sets a Date object based on an ISO 8601 formatted string (time only) // first strip timezone info from the end var timezone = "Z|(([-+])([0-9]{2})(:?([0-9]{2}))?)$"; var d = formattedString.match(new RegExp(timezone)); var offset = 0; // local time if no tz info if(d){ if(d[0] != 'Z'){ offset = (Number(d[3]) * 60) + Number(d[5]); offset *= ((d[2] == '-') ? 1 : -1); } offset -= dateObject.getTimezoneOffset(); formattedString = formattedString.substr(0, formattedString.length - d[0].length); } // then work out the time var regexp = "^([0-9]{2})(:?([0-9]{2})(:?([0-9]{2})(\.([0-9]+))?)?)?$"; d = formattedString.match(new RegExp(regexp)); if(!d){ dojo.debug("invalid time string: " + formattedString); return null; // null } var hours = d[1]; var mins = Number((d[3]) ? d[3] : 0); var secs = (d[5]) ? d[5] : 0; var ms = d[7] ? (Number("0." + d[7]) * 1000) : 0; dateObject.setHours(hours); dateObject.setMinutes(mins); dateObject.setSeconds(secs); dateObject.setMilliseconds(ms); if(offset !== 0){ dateObject.setTime(dateObject.getTime() + offset * 60000); } return dateObject; // Date }; dojo.date.fromIso8601Time = function(/*String*/formattedString){ // summary: returns a Date object based on an ISO 8601 formatted string (date only) return dojo.date.setIso8601Time(new Date(0, 0), formattedString); }; /* RFC-3339 Date Functions *************************/ dojo.date.toRfc3339 = function(/*Date?*/dateObject, /*String?*/selector){ // summary: // Format a JavaScript Date object as a string according to RFC 3339 // // dateObject: // A JavaScript date, or the current date and time, by default // // selector: // "dateOnly" or "timeOnly" to format selected portions of the Date object. // Date and time will be formatted by default. //FIXME: tolerate Number, string input? if(!dateObject){ dateObject = new Date(); } var _ = dojo.string.pad; var formattedDate = []; if(selector != "timeOnly"){ var date = [_(dateObject.getFullYear(),4), _(dateObject.getMonth()+1,2), _(dateObject.getDate(),2)].join('-'); formattedDate.push(date); } if(selector != "dateOnly"){ var time = [_(dateObject.getHours(),2), _(dateObject.getMinutes(),2), _(dateObject.getSeconds(),2)].join(':'); var timezoneOffset = dateObject.getTimezoneOffset(); time += (timezoneOffset > 0 ? "-" : "+") + _(Math.floor(Math.abs(timezoneOffset)/60),2) + ":" + _(Math.abs(timezoneOffset)%60,2); formattedDate.push(time); } return formattedDate.join('T'); // String }; dojo.date.fromRfc3339 = function(/*String*/rfcDate){ // summary: // Create a JavaScript Date object from a string formatted according to RFC 3339 // // rfcDate: // A string such as 2005-06-30T08:05:00-07:00 // "any" is also supported in place of a time. // backwards compatible support for use of "any" instead of just not // including the time if(rfcDate.indexOf("Tany")!=-1){ rfcDate = rfcDate.replace("Tany",""); } var dateObject = new Date(); return dojo.date.setIso8601(dateObject, rfcDate); // Date or null }; dojo.provide("dojo.widget.DatePicker"); dojo.widget.defineWidget( "dojo.widget.DatePicker", dojo.widget.HtmlWidget, { /* summary: Base class for a stand-alone DatePicker widget which makes it easy to select a date, or switch by month and/or year. description: A stand-alone DatePicker widget that makes it easy to select a date, or increment by week, month, and/or year. It is designed to be used on its own, or inside of other widgets to (see dojo.widget.DropdownDatePicker) or other similar combination widgets. Dates attributes passed in the `RFC 3339` format: http://www.faqs.org/rfcs/rfc3339.html (2005-06-30T08:05:00-07:00) so that they are serializable and locale-independent. usage: var datePicker = dojo.widget.createWidget("DatePicker", {}, dojo.byId("datePickerNode")); <div dojoType="DatePicker"></div> */ //start attributes // value: String|Date // form value property if =='today' will be today's date value: "", // name: String // name of the form element name: "", // displayWeeks: Integer // total weeks to display default displayWeeks: 6, // adjustWeeks: Boolean // if true, weekly size of calendar changes to acomodate the month if false, 42 day format is used adjustWeeks: false, // startDate: String|Date // first available date in the calendar set startDate: "1492-10-12", // endDate: String|Date // last available date in the calendar set endDate: "2941-10-12", // weekStartsOn: Integer // adjusts the first day of the week 0==Sunday..6==Saturday weekStartsOn: "", // staticDisplay: Boolean // disable all incremental controls, must pick a date in the current display staticDisplay: false, // dayWidth: String // how to render the names of the days in the header. see dojo.date.getDayNames dayWidth: 'narrow', classNames: { // summary: // stores a list of class names that may be overriden // TODO: this is not good; can't be adjusted via markup, etc. since it's an array previous: "previousMonth", disabledPrevious: "previousMonthDisabled", current: "currentMonth", disabledCurrent: "currentMonthDisabled", next: "nextMonth", disabledNext: "nextMonthDisabled", currentDate: "currentDate", selectedDate: "selectedDate" }, templateString:"<div class=\"datePickerContainer\" dojoAttachPoint=\"datePickerContainerNode\">\r\n\t<table cellspacing=\"0\" cellpadding=\"0\" class=\"calendarContainer\">\r\n\t\t<thead>\r\n\t\t\t<tr>\r\n\t\t\t\t<td class=\"monthWrapper\" valign=\"top\">\r\n\t\t\t\t\t<table class=\"monthContainer\" cellspacing=\"0\" cellpadding=\"0\" border=\"0\">\r\n\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t<td class=\"monthCurve monthCurveTL\" valign=\"top\"></td>\r\n\t\t\t\t\t\t\t<td class=\"monthLabelContainer\" valign=\"top\">\r\n\t\t\t\t\t\t\t\t<span dojoAttachPoint=\"increaseWeekNode\" \r\n\t\t\t\t\t\t\t\t\tdojoAttachEvent=\"onClick: onIncrementWeek;\" \r\n\t\t\t\t\t\t\t\t\tclass=\"incrementControl increase\">\r\n\t\t\t\t\t\t\t\t\t<img src=\"${dojoWidgetModuleUri}templates/images/incrementMonth.png\" \r\n\t\t\t\t\t\t\t\t\talt=\"↓\" style=\"width:7px;height:5px;\" />\r\n\t\t\t\t\t\t\t\t</span>\r\n\t\t\t\t\t\t\t\t<span \r\n\t\t\t\t\t\t\t\t\tdojoAttachPoint=\"increaseMonthNode\" \r\n\t\t\t\t\t\t\t\t\tdojoAttachEvent=\"onClick: onIncrementMonth;\" class=\"incrementControl increase\">\r\n\t\t\t\t\t\t\t\t\t<img src=\"${dojoWidgetModuleUri}templates/images/incrementMonth.png\" \r\n\t\t\t\t\t\t\t\t\t\talt=\"↓\" dojoAttachPoint=\"incrementMonthImageNode\">\r\n\t\t\t\t\t\t\t\t</span>\r\n\t\t\t\t\t\t\t\t<span \r\n\t\t\t\t\t\t\t\t\tdojoAttachPoint=\"decreaseWeekNode\" \r\n\t\t\t\t\t\t\t\t\tdojoAttachEvent=\"onClick: onIncrementWeek;\" \r\n\t\t\t\t\t\t\t\t\tclass=\"incrementControl decrease\">\r\n\t\t\t\t\t\t\t\t\t<img src=\"${dojoWidgetModuleUri}templates/images/decrementMonth.png\" alt=\"↑\" style=\"width:7px;height:5px;\" />\r\n\t\t\t\t\t\t\t\t</span>\r\n\t\t\t\t\t\t\t\t<span \r\n\t\t\t\t\t\t\t\t\tdojoAttachPoint=\"decreaseMonthNode\" \r\n\t\t\t\t\t\t\t\t\tdojoAttachEvent=\"onClick: onIncrementMonth;\" class=\"incrementControl decrease\">\r\n\t\t\t\t\t\t\t\t\t<img src=\"${dojoWidgetModuleUri}templates/images/decrementMonth.png\" \r\n\t\t\t\t\t\t\t\t\t\talt=\"↑\" dojoAttachPoint=\"decrementMonthImageNode\">\r\n\t\t\t\t\t\t\t\t</span>\r\n\t\t\t\t\t\t\t\t<span dojoAttachPoint=\"monthLabelNode\" class=\"month\"></span>\r\n\t\t\t\t\t\t\t</td>\r\n\t\t\t\t\t\t\t<td class=\"monthCurve monthCurveTR\" valign=\"top\"></td>\r\n\t\t\t\t\t\t</tr>\r\n\t\t\t\t\t</table>\r\n\t\t\t\t</td>\r\n\t\t\t</tr>\r\n\t\t</thead>\r\n\t\t<tbody>\r\n\t\t\t<tr>\r\n\t\t\t\t<td colspan=\"3\">\r\n\t\t\t\t\t<table class=\"calendarBodyContainer\" cellspacing=\"0\" cellpadding=\"0\" border=\"0\">\r\n\t\t\t\t\t\t<thead>\r\n\t\t\t\t\t\t\t<tr dojoAttachPoint=\"dayLabelsRow\">\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t</tr>\r\n\t\t\t\t\t\t</thead>\r\n\t\t\t\t\t\t<tbody dojoAttachPoint=\"calendarDatesContainerNode\" \r\n\t\t\t\t\t\t\tdojoAttachEvent=\"onClick: _handleUiClick;\">\r\n\t\t\t\t\t\t\t<tr dojoAttachPoint=\"calendarWeekTemplate\">\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t\t<td></td>\r\n\t\t\t\t\t\t\t</tr>\r\n\t\t\t\t\t\t</tbody>\r\n\t\t\t\t\t</table>\r\n\t\t\t\t</td>\r\n\t\t\t</tr>\r\n\t\t</tbody>\r\n\t\t<tfoot>\r\n\t\t\t<tr>\r\n\t\t\t\t<td colspan=\"3\" class=\"yearWrapper\">\r\n\t\t\t\t\t<table cellspacing=\"0\" cellpadding=\"0\" border=\"0\" class=\"yearContainer\">\r\n\t\t\t\t\t\t<tr>\r\n\t\t\t\t\t\t\t<td class=\"curveBL\" valign=\"top\"></td>\r\n\t\t\t\t\t\t\t<td valign=\"top\">\r\n\t\t\t\t\t\t\t\t<h3 class=\"yearLabel\">\r\n\t\t\t\t\t\t\t\t\t<span dojoAttachPoint=\"previousYearLabelNode\"\r\n\t\t\t\t\t\t\t\t\t\tdojoAttachEvent=\"onClick: onIncrementYear;\" class=\"previousYear\"></span>\r\n\t\t\t\t\t\t\t\t\t<span class=\"selectedYear\" dojoAttachPoint=\"currentYearLabelNode\"></span>\r\n\t\t\t\t\t\t\t\t\t<span dojoAttachPoint=\"nextYearLabelNode\" \r\n\t\t\t\t\t\t\t\t\t\tdojoAttachEvent=\"onClick: onIncrementYear;\" class=\"nextYear\"></span>\r\n\t\t\t\t\t\t\t\t</h3>\r\n\t\t\t\t\t\t\t</td>\r\n\t\t\t\t\t\t\t<td class=\"curveBR\" valign=\"top\"></td>\r\n\t\t\t\t\t\t</tr>\r\n\t\t\t\t\t</table>\r\n\t\t\t\t</td>\r\n\t\t\t</tr>\r\n\t\t</tfoot>\r\n\t</table>\r\n</div>\r\n", templateCssString:".datePickerContainer {\r\n\twidth:164px; /* needed for proper user styling */\r\n}\r\n\r\n.calendarContainer {\r\n/*\tborder:1px solid #566f8f;*/\r\n}\r\n\r\n.calendarBodyContainer {\r\n\twidth:100%; /* needed for the explode effect (explain?) */\r\n\tbackground: #7591bc url(\"images/dpBg.gif\") top left repeat-x;\r\n}\r\n\r\n.calendarBodyContainer thead tr td {\r\n\tcolor:#293a4b;\r\n\tfont:bold 0.75em Helvetica, Arial, Verdana, sans-serif;\r\n\ttext-align:center;\r\n\tpadding:0.25em;\r\n\tbackground: url(\"images/dpHorizLine.gif\") bottom left repeat-x;\r\n}\r\n\r\n.calendarBodyContainer tbody tr td {\r\n\tcolor:#fff;\r\n\tfont:bold 0.7em Helvetica, Arial, Verdana, sans-serif;\r\n\ttext-align:center;\r\n\tpadding:0.4em;\r\n\tbackground: url(\"images/dpVertLine.gif\") top right repeat-y;\r\n\tcursor:pointer;\r\n\tcursor:hand;\r\n}\r\n\r\n\r\n.monthWrapper {\r\n\tpadding-bottom:2px;\r\n\tbackground: url(\"images/dpHorizLine.gif\") bottom left repeat-x;\r\n}\r\n\r\n.monthContainer {\r\n\twidth:100%;\r\n}\r\n\r\n.monthLabelContainer {\r\n\ttext-align:center;\r\n\tfont:bold 0.75em Helvetica, Arial, Verdana, sans-serif;\r\n\tbackground: url(\"images/dpMonthBg.png\") repeat-x top left !important;\r\n\tcolor:#293a4b;\r\n\tpadding:0.25em;\r\n}\r\n\r\n.monthCurve {\r\n\twidth:12px;\r\n}\r\n\r\n.monthCurveTL {\r\n\tbackground: url(\"images/dpCurveTL.png\") no-repeat top left !important;\r\n}\r\n\r\n.monthCurveTR {\r\n\t\tbackground: url(\"images/dpCurveTR.png\") no-repeat top right !important;\r\n}\r\n\r\n\r\n.yearWrapper {\r\n\tbackground: url(\"images/dpHorizLineFoot.gif\") top left repeat-x;\r\n\tpadding-top:2px;\r\n}\r\n\r\n.yearContainer {\r\n\twidth:100%;\r\n}\r\n\r\n.yearContainer td {\r\n\tbackground:url(\"images/dpYearBg.png\") top left repeat-x;\r\n}\r\n\r\n.yearContainer .yearLabel {\r\n\tmargin:0;\r\n\tpadding:0.45em 0 0.45em 0;\r\n\tcolor:#fff;\r\n\tfont:bold 0.75em Helvetica, Arial, Verdana, sans-serif;\r\n\ttext-align:center;\r\n}\r\n\r\n.curveBL {\r\n\tbackground: url(\"images/dpCurveBL.png\") bottom left no-repeat !important;\r\n\twidth:9px !important;\r\n\tpadding:0;\r\n\tmargin:0;\r\n}\r\n\r\n.curveBR {\r\n\tbackground: url(\"images/dpCurveBR.png\") bottom right no-repeat !important;\r\n\twidth:9px !important;\r\n\tpadding:0;\r\n\tmargin:0;\r\n}\r\n\r\n\r\n.previousMonth {\r\n\tbackground-color:#6782a8 !important;\r\n}\r\n\r\n.previousMonthDisabled {\r\n\tbackground-color:#a4a5a6 !important;\r\n\tcursor:default !important\r\n}\r\n.currentMonth {\r\n}\r\n\r\n.currentMonthDisabled {\r\n\tbackground-color:#bbbbbc !important;\r\n\tcursor:default !important\r\n}\r\n.nextMonth {\r\n\tbackground-color:#6782a8 !important;\r\n}\r\n.nextMonthDisabled {\r\n\tbackground-color:#a4a5a6 !important;\r\n\tcursor:default !important;\r\n}\r\n\r\n.currentDate {\r\n\ttext-decoration:underline;\r\n\tfont-style:italic;\r\n}\r\n\r\n.selectedDate {\r\n\tbackground-color:#fff !important;\r\n\tcolor:#6782a8 !important;\r\n}\r\n\r\n.yearLabel .selectedYear {\r\n\tpadding:0.2em;\r\n\tbackground-color:#9ec3fb !important;\r\n}\r\n\r\n.nextYear, .previousYear {\r\n\tcursor:pointer;cursor:hand;\r\n\tpadding:0;\r\n}\r\n\r\n.nextYear {\r\n\tmargin:0 0 0 0.55em;\r\n}\r\n\r\n.previousYear {\r\n\tmargin:0 0.55em 0 0;\r\n}\r\n\r\n.incrementControl {\r\n\tcursor:pointer;cursor:hand;\r\n\twidth:1em;\r\n}\r\n\r\n.increase {\r\n\tfloat:right;\r\n}\r\n\r\n.decrease {\r\n\tfloat:left;\r\n}\r\n\r\n.lastColumn {\r\n\tbackground-image:none !important;\r\n}\r\n\r\n\r\n",templateCssPath: dojo.uri.moduleUri("dojo.widget", "templates/DatePicker.css"), postMixInProperties: function(){ // summary: see dojo.widget.DomWidget dojo.widget.DatePicker.superclass.postMixInProperties.apply(this, arguments); if(!this.weekStartsOn){ this.weekStartsOn=dojo.date.getFirstDayOfWeek(this.lang); } this.today = new Date(); this.today.setHours(0,0,0,0); if(typeof(this.value)=='string'&&this.value.toLowerCase()=='today'){ this.value = new Date(); }else if(this.value && (typeof this.value=="string") && (this.value.split("-").length > 2)) { this.value = dojo.date.fromRfc3339(this.value); this.value.setHours(0,0,0,0); } }, fillInTemplate: function(args, frag) { // summary: see dojo.widget.DomWidget dojo.widget.DatePicker.superclass.fillInTemplate.apply(this, arguments); // Copy style info from input node to output node var source = this.getFragNodeRef(frag); dojo.html.copyStyle(this.domNode, source); this.weekTemplate = dojo.dom.removeNode(this.calendarWeekTemplate); this._preInitUI(this.value ? this.value : this.today, false, true); //init UI with date selected ONLY if user supplies one // Insert localized day names in the template var dayLabels = dojo.lang.unnest(dojo.date.getNames('days', this.dayWidth, 'standAlone', this.lang)); //if we dont use unnest, we risk modifying the dayLabels array inside of dojo.date and screwing up other calendars on the page if(this.weekStartsOn>0){ //adjust dayLabels for different first day of week. ie: Monday or Thursday instead of Sunday for(var i=0;i<this.weekStartsOn;i++){ dayLabels.push(dayLabels.shift()); } } var dayLabelNodes = this.dayLabelsRow.getElementsByTagName("td"); for(i=0; i<7; i++) { dayLabelNodes.item(i).innerHTML = dayLabels[i]; } if(this.value){ this.setValue(this.value); } }, getValue: function() { // summary: return current date in RFC 3339 format return dojo.date.toRfc3339(new Date(this.value),'dateOnly'); /*String*/ }, getDate: function() { // summary: return current date as a Date object return this.value; /*Date*/ }, setValue: function(/*Date|String*/rfcDate) { //summary: set the current date from RFC 3339 formatted string or a date object, synonymous with setDate this.setDate(rfcDate); }, setDate: function(/*Date|String*/dateObj) { //summary: set the current date and update the UI if(dateObj == ""){ this.value = ""; this._preInitUI(this.curMonth,false,true); }else if(typeof dateObj=="string"){ this.value = dojo.date.fromRfc3339(dateObj); this.value.setHours(0,0,0,0); }else{ this.value = new Date(dateObj); this.value.setHours(0,0,0,0); } if(this.selectedNode!=null){ dojo.html.removeClass(this.selectedNode,this.classNames.selectedDate); } if(this.clickedNode!=null){ dojo.debug('adding selectedDate'); dojo.html.addClass(this.clickedNode,this.classNames.selectedDate); this.selectedNode = this.clickedNode; }else{ //only call this if setDate was called by means other than clicking a date this._preInitUI(this.value,false,true); } this.clickedNode=null; this.onValueChanged(this.value); }, _preInitUI: function(dateObj,initFirst,initUI) { /* To get a sense of what month to highlight, we initialize on the first Saturday of each month, since that will be either the first of two or the second of three months being partially displayed, and then work forwards and backwards from that point. */ //initFirst is to tell _initFirstDay if you want first day of the displayed calendar, or first day of the week for dateObj //initUI tells preInitUI to go ahead and run initUI if set to true if(typeof(this.startDate) == "string"){ this.startDate = dojo.date.fromRfc3339(this.startDate); } if(typeof(this.endDate) == "string"){ this.endDate = dojo.date.fromRfc3339(this.endDate); } this.startDate.setHours(0,0,0,0); //adjust startDate to be exactly midnight this.endDate.setHours(24,0,0,-1); //adjusting endDate to be a fraction of a second before midnight if(dateObj<this.startDate||dateObj>this.endDate){ dateObj = new Date((dateObj<this.startDate)?this.startDate:this.endDate); } this.firstDay = this._initFirstDay(dateObj,initFirst); this.selectedIsUsed = false; this.currentIsUsed = false; var nextDate = new Date(this.firstDay); var tmpMonth = nextDate.getMonth(); this.curMonth = new Date(nextDate); this.curMonth.setDate(nextDate.getDate()+6); //first saturday gives us the current Month this.curMonth.setDate(1); if(this.displayWeeks=="" || this.adjustWeeks){ this.adjustWeeks = true; this.displayWeeks = Math.ceil((dojo.date.getDaysInMonth(this.curMonth) + this._getAdjustedDay(this.curMonth))/7); } var days = this.displayWeeks*7; //init total days to display if(dojo.date.diff(this.startDate,this.endDate, dojo.date.dateParts.DAY) < days){ this.staticDisplay = true; if(dojo.date.diff(nextDate,this.endDate, dojo.date.dateParts.DAY) > days){ this._preInitUI(this.startDate,true,false); nextDate = new Date(this.firstDay); } this.curMonth = new Date(nextDate); this.curMonth.setDate(nextDate.getDate()+6); this.curMonth.setDate(1); var curClass = (nextDate.getMonth() == this.curMonth.getMonth())?'current':'previous'; } if(initUI){ this._initUI(days); } }, _initUI: function(days) { dojo.dom.removeChildren(this.calendarDatesContainerNode); for(var i=0;i<this.displayWeeks;i++){ this.calendarDatesContainerNode.appendChild(this.weekTemplate.cloneNode(true)); } var nextDate = new Date(this.firstDay); this._setMonthLabel(this.curMonth.getMonth()); this._setYearLabels(this.curMonth.getFullYear()); var calendarNodes = this.calendarDatesContainerNode.getElementsByTagName("td"); var calendarRows = this.calendarDatesContainerNode.getElementsByTagName("tr"); var currentCalendarNode; for(i=0;i<days;i++){ //this is our new UI loop... one loop to rule them all, and in the datepicker bind them currentCalendarNode = calendarNodes.item(i); currentCalendarNode.innerHTML = nextDate.getDate(); currentCalendarNode.setAttribute("djDateValue",nextDate.valueOf()); var curClass = (nextDate.getMonth() != this.curMonth.getMonth() && Number(nextDate) < Number(this.curMonth))?'previous':(nextDate.getMonth()==this.curMonth.getMonth())?'current':'next'; var mappedClass = curClass; if(this._isDisabledDate(nextDate)){ var classMap={previous:"disabledPrevious",current:"disabledCurrent",next:"disabledNext"}; mappedClass=classMap[curClass]; } dojo.html.setClass(currentCalendarNode, this._getDateClassName(nextDate, mappedClass)); if(dojo.html.hasClass(currentCalendarNode,this.classNames.selectedDate)){ this.selectedNode = currentCalendarNode; } nextDate = dojo.date.add(nextDate, dojo.date.dateParts.DAY, 1); } this.lastDay = dojo.date.add(nextDate,dojo.date.dateParts.DAY,-1); this._initControls(); }, _initControls: function(){ var d = this.firstDay; var d2 = this.lastDay; var decWeek, incWeek, decMonth, incMonth, decYear, incYear; decWeek = incWeek = decMonth = incMonth = decYear = incYear = !this.staticDisplay; with(dojo.date.dateParts){ var add = dojo.date.add; if(decWeek && add(d,DAY,(-1*(this._getAdjustedDay(d)+1)))<this.startDate){ decWeek = decMonth = decYear = false; } if(incWeek && d2>this.endDate){ incWeek = incMonth = incYear = false; } if(decMonth && add(d,DAY,-1)<this.startDate){ decMonth = decYear = false; } if(incMonth && add(d2,DAY,1)>this.endDate){ incMonth = incYear = false; } if(decYear && add(d2,YEAR,-1)<this.startDate){ decYear = false; } if(incYear && add(d,YEAR,1)>this.endDate){ incYear = false; } } function enableControl(node, enabled){ dojo.html.setVisibility(node, enabled ? '' : 'hidden'); } enableControl(this.decreaseWeekNode,decWeek); enableControl(this.increaseWeekNode,incWeek); enableControl(this.decreaseMonthNode,decMonth); enableControl(this.increaseMonthNode,incMonth); enableControl(this.previousYearLabelNode,decYear); enableControl(this.nextYearLabelNode,incYear); }, _incrementWeek: function(evt) { var d = new Date(this.firstDay); switch(evt.target) { case this.increaseWeekNode.getElementsByTagName("img").item(0): case this.increaseWeekNode: var tmpDate = dojo.date.add(d, dojo.date.dateParts.WEEK, 1); if(tmpDate < this.endDate){ d = dojo.date.add(d, dojo.date.dateParts.WEEK, 1); } break; case this.decreaseWeekNode.getElementsByTagName("img").item(0): case this.decreaseWeekNode: if(d >= this.startDate){ d = dojo.date.add(d, dojo.date.dateParts.WEEK, -1); } break; } this._preInitUI(d,true,true); }, _incrementMonth: function(evt) { var d = new Date(this.curMonth); var tmpDate = new Date(this.firstDay); switch(evt.currentTarget) { case this.increaseMonthNode.getElementsByTagName("img").item(0): case this.increaseMonthNode: tmpDate = dojo.date.add(tmpDate, dojo.date.dateParts.DAY, this.displayWeeks*7); if(tmpDate < this.endDate){ d = dojo.date.add(d, dojo.date.dateParts.MONTH, 1); }else{ var revertToEndDate = true; } break; case this.decreaseMonthNode.getElementsByTagName("img").item(0): case this.decreaseMonthNode: if(tmpDate > this.startDate){ d = dojo.date.add(d, dojo.date.dateParts.MONTH, -1); }else{ var revertToStartDate = true; } break; } if(revertToStartDate){ d = new Date(this.startDate); }else if(revertToEndDate){ d = new Date(this.endDate); } this._preInitUI(d,false,true); }, _incrementYear: function(evt) { var year = this.curMonth.getFullYear(); var tmpDate = new Date(this.firstDay); switch(evt.target) { case this.nextYearLabelNode: tmpDate = dojo.date.add(tmpDate, dojo.date.dateParts.YEAR, 1); if(tmpDate<this.endDate){ year++; }else{ var revertToEndDate = true; } break; case this.previousYearLabelNode: tmpDate = dojo.date.add(tmpDate, dojo.date.dateParts.YEAR, -1); if(tmpDate>this.startDate){ year--; }else{ var revertToStartDate = true; } break; } var d; if(revertToStartDate){ d = new Date(this.startDate); }else if(revertToEndDate){ d = new Date(this.endDate); }else{ d = new Date(year, this.curMonth.getMonth(), 1); } this._preInitUI(d,false,true); }, onIncrementWeek: function(/*Event*/evt) { // summary: handler for increment week event evt.stopPropagation(); if(!this.staticDisplay){ this._incrementWeek(evt); } }, onIncrementMonth: function(/*Event*/evt) { // summary: handler for increment month event evt.stopPropagation(); if(!this.staticDisplay){ this._incrementMonth(evt); } }, onIncrementYear: function(/*Event*/evt) { // summary: handler for increment year event evt.stopPropagation(); if(!this.staticDisplay){ this._incrementYear(evt); } }, _setMonthLabel: function(monthIndex) { this.monthLabelNode.innerHTML = dojo.date.getNames('months', 'wide', 'standAlone', this.lang)[monthIndex]; }, _setYearLabels: function(year) { var y = year - 1; var that = this; function f(n){ that[n+"YearLabelNode"].innerHTML = dojo.date.format(new Date(y++, 0), {formatLength:'yearOnly', locale:that.lang}); } f("previous"); f("current"); f("next"); }, _getDateClassName: function(date, monthState) { var currentClassName = this.classNames[monthState]; //we use Number comparisons because 2 dateObjects never seem to equal each other otherwise if ((!this.selectedIsUsed && this.value) && (Number(date) == Number(this.value))) { currentClassName = this.classNames.selectedDate + " " + currentClassName; this.selectedIsUsed = true; } if((!this.currentIsUsed) && (Number(date) == Number(this.today))) { currentClassName = currentClassName + " " + this.classNames.currentDate; this.currentIsUsed = true; } return currentClassName; }, onClick: function(/*Event*/evt) { //summary: the click event handler dojo.event.browser.stopEvent(evt); }, _handleUiClick: function(/*Event*/evt) { var eventTarget = evt.target; if(eventTarget.nodeType != dojo.dom.ELEMENT_NODE){eventTarget = eventTarget.parentNode;} dojo.event.browser.stopEvent(evt); this.selectedIsUsed = this.todayIsUsed = false; if(dojo.html.hasClass(eventTarget, this.classNames["disabledPrevious"])||dojo.html.hasClass(eventTarget, this.classNames["disabledCurrent"])||dojo.html.hasClass(eventTarget, this.classNames["disabledNext"])){ return; //this date is disabled... ignore it } this.clickedNode = eventTarget; this.setDate(new Date(Number(dojo.html.getAttribute(eventTarget,'djDateValue')))); }, onValueChanged: function(/*Date*/date) { //summary: the set date event handler }, _isDisabledDate: function(dateObj){ if(dateObj<this.startDate||dateObj>this.endDate){ return true; } return this.isDisabledDate(dateObj, this.lang); }, isDisabledDate: function(/*Date*/dateObj, /*String?*/locale){ // summary: // May be overridden to disable certain dates in the calendar e.g. isDisabledDate=dojo.date.isWeekend return false; // Boolean }, _initFirstDay: function(/*Date*/dateObj, /*Boolean*/adj){ //adj: false for first day of month, true for first day of week adjusted by startOfWeek var d = new Date(dateObj); if(!adj){d.setDate(1);} d.setDate(d.getDate()-this._getAdjustedDay(d,this.weekStartsOn)); d.setHours(0,0,0,0); return d; // Date }, _getAdjustedDay: function(/*Date*/dateObj){ //summary: used to adjust date.getDay() values to the new values based on the current first day of the week value var days = [0,1,2,3,4,5,6]; if(this.weekStartsOn>0){ for(var i=0;i<this.weekStartsOn;i++){ days.unshift(days.pop()); } } return days[dateObj.getDay()]; // Number: 0..6 where 0=Sunday }, destroy: function(){ dojo.widget.DatePicker.superclass.destroy.apply(this, arguments); dojo.html.destroyNode(this.weekTemplate); } } ); dojo.provide("dojo.widget.DropdownDatePicker"); dojo.widget.defineWidget( "dojo.widget.DropdownDatePicker", dojo.widget.DropdownContainer, { /* summary: A form input for entering dates with a pop-up dojo.widget.DatePicker to aid in selection description: This is DatePicker in a DropdownContainer, it supports all features of DatePicker. The value displayed in the widget is localized according to the default algorithm provided in dojo.date.format and dojo.date.parse. It is possible to customize the user-visible formatting with either the formatLength or displayFormat attributes. The value sent to the server is typically a locale-independent value in a hidden field as defined by the name attribute. RFC3339 representation is used by default, but other options are available with saveFormat. usage: var ddp = dojo.widget.createWidget("DropdownDatePicker", {}, dojo.byId("DropdownDatePickerNode")); <input dojoType="DropdownDatePicker"> */ iconURL: dojo.uri.moduleUri("dojo.widget", "templates/images/dateIcon.gif"), // formatLength: String // Type of formatting used for visual display, appropriate to locale (choice of long, short, medium or full) // See dojo.date.format for details. formatLength: "short", // displayFormat: String // A pattern used for the visual display of the formatted date, e.g. dd/MM/yyyy. // Setting this overrides the default locale-specific settings as well as the formatLength // attribute. See dojo.date.format for a reference which defines the formatting patterns. displayFormat: "", // saveFormat: String // Formatting scheme used when submitting the form element. This formatting is used in a hidden // field (name) intended for server use, and is therefore typically locale-independent. // By default, uses rfc3339 style date formatting (rfc) // Use a pattern string like displayFormat or one of the following: // rfc|iso|posix|unix saveFormat: "", // value: String|Date // form value property in rfc3339 format. If =='today', will use today's date value: "", // name: String // name of the form element, used to create a hidden field by this name for form element submission. name: "", // Implement various attributes from DatePicker // displayWeeks: Integer // number of weeks to display displayWeeks: 6, // adjustWeeks: Boolean // if true, weekly size of calendar changes to accomodate the month if false, 42 day format is used adjustWeeks: false, // startDate: String|Date // first available date in the calendar set startDate: "1492-10-12", // endDate: String|Date // last available date in the calendar set endDate: "2941-10-12", // weekStartsOn: Integer // adjusts the first day of the week 0==Sunday..6==Saturday weekStartsOn: "", // staticDisplay: Boolean // disable all incremental controls, must pick a date in the current display staticDisplay: false, postMixInProperties: function(localProperties, frag){ // summary: see dojo.widget.DomWidget dojo.widget.DropdownDatePicker.superclass.postMixInProperties.apply(this, arguments); var messages = dojo.i18n.getLocalization("dojo.widget", "DropdownDatePicker", this.lang); this.iconAlt = messages.selectDate; //FIXME: should this be if/else/else? if(typeof(this.value)=='string'&&this.value.toLowerCase()=='today'){ this.value = new Date(); } if(this.value && isNaN(this.value)){ var orig = this.value; this.value = dojo.date.fromRfc3339(this.value); if(!this.value){this.value = new Date(orig); dojo.deprecated("dojo.widget.DropdownDatePicker", "date attributes must be passed in Rfc3339 format", "0.5");} } if(this.value && !isNaN(this.value)){ this.value = new Date(this.value); } }, fillInTemplate: function(args, frag){ // summary: see dojo.widget.DomWidget dojo.widget.DropdownDatePicker.superclass.fillInTemplate.call(this, args, frag); //attributes to be passed on to DatePicker var dpArgs = {widgetContainerId: this.widgetId, lang: this.lang, value: this.value, startDate: this.startDate, endDate: this.endDate, displayWeeks: this.displayWeeks, weekStartsOn: this.weekStartsOn, adjustWeeks: this.adjustWeeks, staticDisplay: this.staticDisplay}; //build the args for DatePicker based on the public attributes of DropdownDatePicker this.datePicker = dojo.widget.createWidget("DatePicker", dpArgs, this.containerNode, "child"); dojo.event.connect(this.datePicker, "onValueChanged", this, "_updateText"); dojo.event.connect(this.inputNode, "onChange", this, "_updateText"); if(this.value){ this._updateText(); } this.containerNode.explodeClassName = "calendarBodyContainer"; this.valueNode.name=this.name; }, getValue: function(){ // summary: return current date in RFC 3339 format return this.valueNode.value; /*String*/ }, getDate: function(){ // summary: return current date as a Date object return this.datePicker.value; /*Date*/ }, setValue: function(/*Date|String*/rfcDate){ //summary: set the current date from RFC 3339 formatted string or a date object, synonymous with setDate this.setDate(rfcDate); }, setDate: function(/*Date|String*/dateObj){ // summary: set the current date and update the UI this.datePicker.setDate(dateObj); this._syncValueNode(); }, _updateText: function(){ // summary: updates the <input> field according to the current value (ie, displays the formatted date) this.inputNode.value = this.datePicker.value ? dojo.date.format(this.datePicker.value, {formatLength:this.formatLength, datePattern:this.displayFormat, selector:'dateOnly', locale:this.lang}) : ""; if(this.value < this.datePicker.startDate||this.value>this.datePicker.endDate){ this.inputNode.value = ""; } this._syncValueNode(); this.onValueChanged(this.getDate()); this.hideContainer(); }, onValueChanged: function(/*Date*/dateObj){ //summary: triggered when this.value is changed }, onInputChange: function(){ // summary: callback when user manually types a date into the <input> field var input = dojo.string.trim(this.inputNode.value); if(input){ var inputDate = dojo.date.parse(input, {formatLength:this.formatLength, datePattern:this.displayFormat, selector:'dateOnly', locale:this.lang}); // if inputDate is in a valid range, we call setDate if(!this.datePicker._isDisabledDate(inputDate)){ this.setDate(inputDate); } } else { if(input=="") { this.datePicker.setDate(""); } this.valueNode.value = input; } // If the date entered didn't parse, reset to the old date. KISS, for now. //TODO: usability? should we provide more feedback somehow? an error notice? // seems redundant to do this if the parse failed, but at least until we have validation, // this will fix up the display of entries like 01/32/2006 if(input){ this._updateText(); } }, _syncValueNode: function(){ var date = this.datePicker.value; var value = ""; switch(this.saveFormat.toLowerCase()){ case "rfc": case "iso": case "": value = dojo.date.toRfc3339(date, 'dateOnly'); break; case "posix": case "unix": value = Number(date); break; default: if(date){ value = dojo.date.format(date, {datePattern:this.saveFormat, selector:'dateOnly', locale:this.lang}); } } this.valueNode.value = value; }, destroy: function(/*Boolean*/finalize){ this.datePicker.destroy(finalize); dojo.widget.DropdownDatePicker.superclass.destroy.apply(this, arguments); } } ); dojo.kwCompoundRequire({ common: ["dojo.dnd.DragAndDrop"], browser: ["dojo.dnd.HtmlDragAndDrop"], dashboard: ["dojo.dnd.HtmlDragAndDrop"] }); dojo.provide("dojo.dnd.*"); if(!this["dojo"]){ alert("\"dojo/__package__.js\" is now located at \"dojo/dojo.js\". Please update your includes accordingly"); }