Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo.i18n"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo.i18n"] = true;

dojo.provide("dojo.i18n");

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.  NOTE:

	//		try not to call this method as part of an object property

	//		definition (var foo = { bar: dojo.i18n.getLocalization() }).  In

	//		some loading situations, the bundle may not be available in time

	//		for the object definition.  Instead, call this method inside a

	//		function that is run after all modules load or the page loads (like

	//		in dojo.adOnLoad()), or in a widget lifecycle method.

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

	locale = dojo.i18n.normalizeLocale(locale);

	// look for nearest locale match

	var elements = locale.split('-');

	var module = [packageName,"nls",bundleName].join('.');

	var bundle = dojo._loadedModules[module];

	if(bundle){

		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

		}

	}

	throw new Error("Bundle not found: " + bundleName + " in " + packageName+" , locale=" + locale);

};

dojo.i18n.normalizeLocale = function(/*String?*/locale){

	//	summary:

	//		Returns canonical form of locale, as used by Dojo.

	//

	//  description:

	//		All variants are case-insensitive and are separated by '-' as specified in RFC 3066.

	//		If no locale is specified, the dojo.locale is returned.  dojo.locale is defined by

	//		the user agent's locale unless overridden by djConfig.

	var result = locale ? locale.toLowerCase() : dojo.locale;

	if(result == "root"){

		result = "ROOT";

	}

	return result; // String

};

dojo.i18n._requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){

	//	summary:

	//		See dojo.requireLocalization()

	//	description:

	// 		Called by the bootstrap, but factored out so that it is only

	// 		included in the build when needed.

	var targetLocale = dojo.i18n.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._loadedModules[bundlePackage];

	var localizedBundle = null;

	if(bundle){

		if(djConfig.localizationComplete && bundle._built){return;}

		var jsLoc = tempLocale.replace(/-/g, '_');

		var translationPackage = bundlePackage+"."+jsLoc;

		localizedBundle = dojo._loadedModules[translationPackage];

	}

	if(!localizedBundle){

		bundle = dojo["provide"](bundlePackage);

		var syms = dojo._getModuleSymbols(moduleName);

		var modpath = syms.concat("nls").join("/");

		var parent;

		dojo.i18n._searchLocalePath(tempLocale, availableFlatLocales, function(loc){

			var jsLoc = loc.replace(/-/g, '_');

			var translationPackage = bundlePackage + "." + jsLoc;

			var loaded = false;

			if(!dojo._loadedModules[translationPackage]){

				// Mark loaded whether it's found or not, so that further load attempts will not be made

				dojo["provide"](translationPackage);

				var module = [modpath];

				if(loc != "ROOT"){module.push(loc);}

				module.push(bundleName);

				var filespec = module.join("/") + '.js';

				loaded = dojo._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(/-/g, '_')] = bundle[bestLocale.replace(/-/g, '_')];

	}

};

(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.i18n._requireLocalization;

		dojo.i18n._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);

			}

		};

	}

})();

dojo.i18n._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.i18n.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.i18n._preloadLocalizations = function(/*String*/bundlePrefix, /*Array*/localesGenerated){

	//	summary:

	//		Load built, flattened resource bundles, if available for all

	//		locales used in the page. Only called by built layer files.

	function preload(locale){

		locale = dojo.i18n.normalizeLocale(locale);

		dojo.i18n._searchLocalePath(locale, true, function(loc){

			for(var i=0; i<localesGenerated.length;i++){

				if(localesGenerated[i] == loc){

					dojo["require"](bundlePrefix+"_"+loc);

					return true; // Boolean

				}

			}

			return false; // Boolean

		});

	}

	preload();

	var extra = djConfig.extraLocale||[];

	for(var i=0; i<extra.length; i++){

		preload(extra[i]);

	}

};

}