Rev 1422 | Blame | Last modification | View Log | RSS feed
/*
Copyright (c) 2004-2006, The Dojo Foundation
All Rights Reserved.
Licensed under the Academic Free License version 2.1 or above OR the
modified BSD license. For more information on Dojo licensing, see:
http://dojotoolkit.org/community/licensing.shtml
*/
dojo.hostenv.resetXd = function () {
this.isXDomain = djConfig.useXDomain || false;
this.xdTimer = 0;
this.xdInFlight = {};
this.xdOrderedReqs = [];
this.xdDepMap = {};
this.xdContents = [];
this.xdDefList = [];
};
dojo.hostenv.resetXd();
dojo.hostenv.createXdPackage = function (contents, resourceName, resourcePath) {
var deps = [];
var depRegExp = /dojo.(requireLocalization|require|requireIf|requireAll|provide|requireAfterIf|requireAfter|kwCompoundRequire|conditionalRequire|hostenv\.conditionalLoadModule|.hostenv\.loadModule|hostenv\.moduleLoaded)\(([\w\W]*?)\)/mg;
var match;
while ((match = depRegExp.exec(contents)) != null) {
if (match[1] == "requireLocalization") {
eval(match[0]);
} else {
deps.push("\"" + match[1] + "\", " + match[2]);
}
}
var output = [];
output.push("dojo.hostenv.packageLoaded({\n");
if (deps.length > 0) {
output.push("depends: [");
for (var i = 0; i < deps.length; i++) {
if (i > 0) {
output.push(",\n");
}
output.push("[" + deps[i] + "]");
}
output.push("],");
}
output.push("\ndefinePackage: function(dojo){");
output.push(contents);
output.push("\n}, resourceName: '" + resourceName + "', resourcePath: '" + resourcePath + "'});");
return output.join("");
};
dojo.hostenv.loadPath = function (relpath, module, cb) {
var colonIndex = relpath.indexOf(":");
var slashIndex = relpath.indexOf("/");
var uri;
var currentIsXDomain = false;
if (colonIndex > 0 && colonIndex < slashIndex) {
uri = relpath;
this.isXDomain = currentIsXDomain = true;
} else {
uri = this.getBaseScriptUri() + relpath;
colonIndex = uri.indexOf(":");
slashIndex = uri.indexOf("/");
if (colonIndex > 0 && colonIndex < slashIndex && (!location.host || uri.indexOf("http://" + location.host) != 0)) {
this.isXDomain = currentIsXDomain = true;
}
}
if (djConfig.cacheBust && dojo.render.html.capable) {
uri += "?" + String(djConfig.cacheBust).replace(/\W+/g, "");
}
try {
return ((!module || this.isXDomain) ? this.loadUri(uri, cb, currentIsXDomain, module) : this.loadUriAndCheck(uri, module, cb));
}
catch (e) {
dojo.debug(e);
return false;
}
};
dojo.hostenv.loadUri = function (uri, cb, currentIsXDomain, module) {
if (this.loadedUris[uri]) {
return 1;
}
if (this.isXDomain && module) {
if (uri.indexOf("__package__") != -1) {
module += ".*";
}
this.xdOrderedReqs.push(module);
if (currentIsXDomain || uri.indexOf("/nls/") == -1) {
this.xdInFlight[module] = true;
this.inFlightCount++;
}
if (!this.xdTimer) {
this.xdTimer = setInterval("dojo.hostenv.watchInFlightXDomain();", 100);
}
this.xdStartTime = (new Date()).getTime();
}
if (currentIsXDomain) {
var lastIndex = uri.lastIndexOf(".");
if (lastIndex <= 0) {
lastIndex = uri.length - 1;
}
var xdUri = uri.substring(0, lastIndex) + ".xd";
if (lastIndex != uri.length - 1) {
xdUri += uri.substring(lastIndex, uri.length);
}
var element = document.createElement("script");
element.type = "text/javascript";
element.src = xdUri;
if (!this.headElement) {
this.headElement = document.getElementsByTagName("head")[0];
if (!this.headElement) {
this.headElement = document.getElementsByTagName("html")[0];
}
}
this.headElement.appendChild(element);
} else {
var contents = this.getText(uri, null, true);
if (contents == null) {
return 0;
}
if (this.isXDomain && uri.indexOf("/nls/") == -1) {
var pkg = this.createXdPackage(contents, module, uri);
dj_eval(pkg);
} else {
if (cb) {
contents = "(" + contents + ")";
}
var value = dj_eval(contents);
if (cb) {
cb(value);
}
}
}
this.loadedUris[uri] = true;
return 1;
};
dojo.hostenv.packageLoaded = function (pkg) {
var deps = pkg.depends;
var requireList = null;
var requireAfterList = null;
var provideList = [];
if (deps && deps.length > 0) {
var dep = null;
var insertHint = 0;
var attachedPackage = false;
for (var i = 0; i < deps.length; i++) {
dep = deps[i];
if (dep[0] == "provide" || dep[0] == "hostenv.moduleLoaded") {
provideList.push(dep[1]);
} else {
if (!requireList) {
requireList = [];
}
if (!requireAfterList) {
requireAfterList = [];
}
var unpackedDeps = this.unpackXdDependency(dep);
if (unpackedDeps.requires) {
requireList = requireList.concat(unpackedDeps.requires);
}
if (unpackedDeps.requiresAfter) {
requireAfterList = requireAfterList.concat(unpackedDeps.requiresAfter);
}
}
var depType = dep[0];
var objPath = depType.split(".");
if (objPath.length == 2) {
dojo[objPath[0]][objPath[1]].apply(dojo[objPath[0]], dep.slice(1));
} else {
dojo[depType].apply(dojo, dep.slice(1));
}
}
var contentIndex = this.xdContents.push({content:pkg.definePackage, resourceName:pkg["resourceName"], resourcePath:pkg["resourcePath"], isDefined:false}) - 1;
for (var i = 0; i < provideList.length; i++) {
this.xdDepMap[provideList[i]] = {requires:requireList, requiresAfter:requireAfterList, contentIndex:contentIndex};
}
for (var i = 0; i < provideList.length; i++) {
this.xdInFlight[provideList[i]] = false;
}
}
};
dojo.hostenv.xdLoadFlattenedBundle = function (moduleName, bundleName, locale, bundleData) {
locale = locale || "root";
var jsLoc = dojo.hostenv.normalizeLocale(locale).replace("-", "_");
var bundlePackage = [moduleName, "nls", bundleName].join(".");
var bundle = dojo.hostenv.startPackage(bundlePackage);
bundle[jsLoc] = bundleData;
var mapName = [moduleName, jsLoc, bundleName].join(".");
var bundleMap = dojo.hostenv.xdBundleMap[mapName];
if (bundleMap) {
for (var param in bundleMap) {
bundle[param] = bundleData;
}
}
};
dojo.hostenv.xdBundleMap = {};
dojo.xdRequireLocalization = function (moduleName, bundleName, locale, availableFlatLocales) {
var locales = availableFlatLocales.split(",");
var jsLoc = dojo.hostenv.normalizeLocale(locale);
var bestLocale = "";
for (var i = 0; i < locales.length; i++) {
if (jsLoc.indexOf(locales[i]) == 0) {
if (locales[i].length > bestLocale.length) {
bestLocale = locales[i];
}
}
}
var fixedBestLocale = bestLocale.replace("-", "_");
var bundlePackage = dojo.evalObjPath([moduleName, "nls", bundleName].join("."));
if (bundlePackage && bundlePackage[fixedBestLocale]) {
bundle[jsLoc.replace("-", "_")] = bundlePackage[fixedBestLocale];
} else {
var mapName = [moduleName, (fixedBestLocale || "root"), bundleName].join(".");
var bundleMap = dojo.hostenv.xdBundleMap[mapName];
if (!bundleMap) {
bundleMap = dojo.hostenv.xdBundleMap[mapName] = {};
}
bundleMap[jsLoc.replace("-", "_")] = true;
dojo.require(moduleName + ".nls" + (bestLocale ? "." + bestLocale : "") + "." + bundleName);
}
};
(function () {
var extra = djConfig.extraLocale;
if (extra) {
if (!extra instanceof Array) {
extra = [extra];
}
dojo._xdReqLoc = dojo.xdRequireLocalization;
dojo.xdRequireLocalization = function (m, b, locale, fLocales) {
dojo._xdReqLoc(m, b, locale, fLocales);
if (locale) {
return;
}
for (var i = 0; i < extra.length; i++) {
dojo._xdReqLoc(m, b, extra[i], fLocales);
}
};
}
})();
dojo.hostenv.unpackXdDependency = function (dep) {
var newDeps = null;
var newAfterDeps = null;
switch (dep[0]) {
case "requireIf":
case "requireAfterIf":
case "conditionalRequire":
if ((dep[1] === true) || (dep[1] == "common") || (dep[1] && dojo.render[dep[1]].capable)) {
newDeps = [{name:dep[2], content:null}];
}
break;
case "requireAll":
dep.shift();
newDeps = dep;
dojo.hostenv.flattenRequireArray(newDeps);
break;
case "kwCompoundRequire":
case "hostenv.conditionalLoadModule":
var modMap = dep[1];
var common = modMap["common"] || [];
var newDeps = (modMap[dojo.hostenv.name_]) ? common.concat(modMap[dojo.hostenv.name_] || []) : common.concat(modMap["default"] || []);
dojo.hostenv.flattenRequireArray(newDeps);
break;
case "require":
case "requireAfter":
case "hostenv.loadModule":
newDeps = [{name:dep[1], content:null}];
break;
}
if (dep[0] == "requireAfterIf" || dep[0] == "requireIf") {
newAfterDeps = newDeps;
newDeps = null;
}
return {requires:newDeps, requiresAfter:newAfterDeps};
};
dojo.hostenv.xdWalkReqs = function () {
var reqChain = null;
var req;
for (var i = 0; i < this.xdOrderedReqs.length; i++) {
req = this.xdOrderedReqs[i];
if (this.xdDepMap[req]) {
reqChain = [req];
reqChain[req] = true;
this.xdEvalReqs(reqChain);
}
}
};
dojo.hostenv.xdEvalReqs = function (reqChain) {
while (reqChain.length > 0) {
var req = reqChain[reqChain.length - 1];
var pkg = this.xdDepMap[req];
if (pkg) {
var reqs = pkg.requires;
if (reqs && reqs.length > 0) {
var nextReq;
for (var i = 0; i < reqs.length; i++) {
nextReq = reqs[i].name;
if (nextReq && !reqChain[nextReq]) {
reqChain.push(nextReq);
reqChain[nextReq] = true;
this.xdEvalReqs(reqChain);
}
}
}
var contents = this.xdContents[pkg.contentIndex];
if (!contents.isDefined) {
var content = contents.content;
content["resourceName"] = contents["resourceName"];
content["resourcePath"] = contents["resourcePath"];
this.xdDefList.push(content);
contents.isDefined = true;
}
this.xdDepMap[req] = null;
var reqs = pkg.requiresAfter;
if (reqs && reqs.length > 0) {
var nextReq;
for (var i = 0; i < reqs.length; i++) {
nextReq = reqs[i].name;
if (nextReq && !reqChain[nextReq]) {
reqChain.push(nextReq);
reqChain[nextReq] = true;
this.xdEvalReqs(reqChain);
}
}
}
}
reqChain.pop();
}
};
dojo.hostenv.clearXdInterval = function () {
clearInterval(this.xdTimer);
this.xdTimer = 0;
};
dojo.hostenv.watchInFlightXDomain = function () {
var waitInterval = (djConfig.xdWaitSeconds || 15) * 1000;
if (this.xdStartTime + waitInterval < (new Date()).getTime()) {
this.clearXdInterval();
var noLoads = "";
for (var param in this.xdInFlight) {
if (this.xdInFlight[param]) {
noLoads += param + " ";
}
}
dojo.raise("Could not load cross-domain packages: " + noLoads);
}
for (var param in this.xdInFlight) {
if (this.xdInFlight[param]) {
return;
}
}
this.clearXdInterval();
this.xdWalkReqs();
var defLength = this.xdDefList.length;
for (var i = 0; i < defLength; i++) {
var content = dojo.hostenv.xdDefList[i];
if (djConfig["debugAtAllCosts"] && content["resourceName"]) {
if (!this["xdDebugQueue"]) {
this.xdDebugQueue = [];
}
this.xdDebugQueue.push({resourceName:content.resourceName, resourcePath:content.resourcePath});
} else {
content(dojo);
}
}
for (var i = 0; i < this.xdContents.length; i++) {
var current = this.xdContents[i];
if (current.content && !current.isDefined) {
current.content(dojo);
}
}
this.resetXd();
if (this["xdDebugQueue"] && this.xdDebugQueue.length > 0) {
this.xdDebugFileLoaded();
} else {
this.xdNotifyLoaded();
}
};
dojo.hostenv.xdNotifyLoaded = function () {
this.inFlightCount = 0;
if (this._djInitFired && !this.loadNotifying) {
this.callLoaded();
}
};
dojo.hostenv.flattenRequireArray = function (target) {
if (target) {
for (var i = 0; i < target.length; i++) {
if (target[i] instanceof Array) {
target[i] = {name:target[i][0], content:null};
} else {
target[i] = {name:target[i], content:null};
}
}
}
};
dojo.hostenv.xdHasCalledPreload = false;
dojo.hostenv.xdRealCallLoaded = dojo.hostenv.callLoaded;
dojo.hostenv.callLoaded = function () {
if (this.xdHasCalledPreload || dojo.hostenv.getModulePrefix("dojo") == "src" || !this.localesGenerated) {
this.xdRealCallLoaded();
} else {
if (this.localesGenerated) {
this.registerNlsPrefix = function () {
dojo.registerModulePath("nls", dojo.hostenv.getModulePrefix("dojo") + "/../nls");
};
this.preloadLocalizations();
}
}
this.xdHasCalledPreload = true;
};