Subversion Repositories Applications.papyrus

/*
        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
*/

(function () {
        var _addHostEnv = {pkgFileName:"__package__", loading_modules_:{}, loaded_modules_:{}, addedToLoadingCount:[], removedFromLoadingCount:[], inFlightCount:0, modulePrefixes_:{dojo:{name:"dojo", value:"src"}}, setModulePrefix:function (module, prefix) {
                this.modulePrefixes_[module] = {name:module, value:prefix};
        }, moduleHasPrefix:function (module) {
                var mp = this.modulePrefixes_;
                return Boolean(mp[module] && mp[module].value);
        }, getModulePrefix:function (module) {
                if (this.moduleHasPrefix(module)) {
                        return this.modulePrefixes_[module].value;
                }
                return module;
        }, getTextStack:[], loadUriStack:[], loadedUris:[], post_load_:false, modulesLoadedListeners:[], unloadListeners:[], loadNotifying:false};
        for (var param in _addHostEnv) {
                dojo.hostenv[param] = _addHostEnv[param];
        }
})();
dojo.hostenv.loadPath = function (relpath, module, cb) {
        var uri;
        if (relpath.charAt(0) == "/" || relpath.match(/^\w+:/)) {
                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);
        }
        catch (e) {
                dojo.debug(e);
                return false;
        }
};
dojo.hostenv.loadUri = function (uri, cb) {
        if (this.loadedUris[uri]) {
                return true;
        }
        var contents = this.getText(uri, null, true);
        if (!contents) {
                return false;
        }
        this.loadedUris[uri] = true;
        if (cb) {
                contents = "(" + contents + ")";
        }
        var value = dj_eval(contents);
        if (cb) {
                cb(value);
        }
        return true;
};
dojo.hostenv.loadUriAndCheck = function (uri, moduleName, cb) {
        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));
};
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]();
        }
        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 (obj, functionName) {
        var dh = dojo.hostenv;
        if (arguments.length == 1) {
                dh.modulesLoadedListeners.push(obj);
        } else {
                if (arguments.length > 1) {
                        dh.modulesLoadedListeners.push(function () {
                                obj[functionName]();
                        });
                }
        }
        if (dh.post_load_ && dh.inFlightCount == 0 && !dh.loadNotifying) {
                dh.callLoaded();
        }
};
dojo.addOnUnload = function (obj, functionName) {
        var dh = dojo.hostenv;
        if (arguments.length == 1) {
                dh.unloadListeners.push(obj);
        } else {
                if (arguments.length > 1) {
                        dh.unloadListeners.push(function () {
                                obj[functionName]();
                        });
                }
        }
};
dojo.hostenv.modulesLoaded = function () {
        if (this.post_load_) {
                return;
        }
        if (this.loadUriStack.length == 0 && this.getTextStack.length == 0) {
                if (this.inFlightCount > 0) {
                        dojo.debug("files still in flight!");
                        return;
                }
                dojo.hostenv.callLoaded();
        }
};
dojo.hostenv.callLoaded = function () {
        if (typeof setTimeout == "object" || (djConfig["useXDomain"] && dojo.render.html.opera)) {
                setTimeout("dojo.hostenv.loaded();", 0);
        } else {
                dojo.hostenv.loaded();
        }
};
dojo.hostenv.getModuleSymbols = function (modulename) {
        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)) {
                        syms[0] = "../" + syms[0];
                } else {
                        var parentModulePath = this.getModulePrefix(parentModule);
                        if (parentModulePath != parentModule) {
                                syms.splice(0, i, parentModulePath);
                                break;
                        }
                }
        }
        return syms;
};
dojo.hostenv._global_omit_module_check = false;
dojo.hostenv.loadModule = function (moduleName, exactOnly, omitModuleCheck) {
        if (!moduleName) {
                return;
        }
        omitModuleCheck = this._global_omit_module_check || omitModuleCheck;
        var module = this.findModule(moduleName, false);
        if (module) {
                return module;
        }
        if (dj_undef(moduleName, this.loading_modules_)) {
                this.addedToLoadingCount.push(moduleName);
        }
        this.loading_modules_[moduleName] = 1;
        var relpath = moduleName.replace(/\./g, "/") + ".js";
        var nsyms = moduleName.split(".");
        var syms = this.getModuleSymbols(moduleName);
        var startedRelative = ((syms[0].charAt(0) != "/") && !syms[0].match(/^\w+:/));
        var last = syms[syms.length - 1];
        var ok;
        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 + "'");
                }
        }
        if (!omitModuleCheck && !this["isXDomain"]) {
                module = this.findModule(moduleName, false);
                if (!module) {
                        dojo.raise("symbol '" + moduleName + "' is not defined after loading '" + relpath + "'");
                }
        }
        return module;
};
dojo.hostenv.startPackage = function (packageName) {
        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;
};
dojo.hostenv.findModule = function (moduleName, mustExist) {
        var lmn = String(moduleName);
        if (this.loaded_modules_[lmn]) {
                return this.loaded_modules_[lmn];
        }
        if (mustExist) {
                dojo.raise("no loaded module named '" + moduleName + "'");
        }
        return null;
};
dojo.kwCompoundRequire = function (modMap) {
        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 (resourceName) {
        dojo.hostenv.loadModule.apply(dojo.hostenv, arguments);
};
dojo.requireIf = function (condition, resourceName) {
        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 (resourceName) {
        return dojo.hostenv.startPackage.apply(dojo.hostenv, arguments);
};
dojo.registerModulePath = function (module, prefix) {
        return dojo.hostenv.setModulePrefix(module, prefix);
};
if (djConfig["modulePaths"]) {
        for (var param in djConfig["modulePaths"]) {
                dojo.registerModulePath(param, djConfig["modulePaths"][param]);
        }
}
dojo.setModulePrefix = function (module, prefix) {
        dojo.deprecated("dojo.setModulePrefix(\"" + module + "\", \"" + prefix + "\")", "replaced by dojo.registerModulePath", "0.5");
        return dojo.registerModulePath(module, prefix);
};
dojo.exists = function (obj, name) {
        var p = name.split(".");
        for (var i = 0; i < p.length; i++) {
                if (!obj[p[i]]) {
                        return false;
                }
                obj = obj[p[i]];
        }
        return true;
};
dojo.hostenv.normalizeLocale = function (locale) {
        var result = locale ? locale.toLowerCase() : dojo.locale;
        if (result == "root") {
                result = "ROOT";
        }
        return result;
};
dojo.hostenv.searchLocalePath = function (locale, down, searchFunc) {
        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;
                }
        }
};
dojo.hostenv.localesGenerated;
dojo.hostenv.registerNlsPrefix = function () {
        dojo.registerModulePath("nls", "nls");
};
dojo.hostenv.preloadLocalizations = function () {
        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;
                                        }
                                }
                                return false;
                        });
                }
                preload();
                var extra = djConfig.extraLocale || [];
                for (var i = 0; i < extra.length; i++) {
                        preload(extra[i]);
                }
        }
        dojo.hostenv.preloadLocalizations = function () {
        };
};
dojo.requireLocalization = function (moduleName, bundleName, locale, availableFlatLocales) {
        dojo.hostenv.preloadLocalizations();
        var targetLocale = dojo.hostenv.normalizeLocale(locale);
        var bundlePackage = [moduleName, "nls", bundleName].join(".");
        var bestLocale = "";
        if (availableFlatLocales) {
                var flatLocales = availableFlatLocales.split(",");
                for (var i = 0; i < flatLocales.length; i++) {
                        if (targetLocale.indexOf(flatLocales[i]) == 0) {
                                if (flatLocales[i].length > bestLocale.length) {
                                        bestLocale = flatLocales[i];
                                }
                        }
                }
                if (!bestLocale) {
                        bestLocale = "ROOT";
                }
        }
        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)) {
                                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) {
                                        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) {
                                return true;
                        }
                });
        }
        if (availableFlatLocales && targetLocale != bestLocale) {
                bundle[targetLocale.replace("-", "_")] = bundle[bestLocale.replace("-", "_")];
        }
};
(function () {
        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);
                        }
                };
        }
})();