176 lines
8.0 KiB
JavaScript
176 lines
8.0 KiB
JavaScript
//>>built
|
|
define("dojo/_base/config", ["../has", "require"], function(has, require){
|
|
// module:
|
|
// dojo/_base/config
|
|
// summary:
|
|
// This module defines the user configuration during bootstrap.
|
|
// description:
|
|
// By defining user configuration as a module value, an entire configuration can be specified in a build,
|
|
// thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
|
|
// Also, when multiple instances of dojo exist in a single application, each will necessarily be located
|
|
// at an unique absolute module identifier as given by the package configuration. Implementing configuration
|
|
// as a module allows for specifying unique, per-instance configurations.
|
|
// example:
|
|
// Create a second instance of dojo with a different, instance-uniqe configuration (assume the loader and
|
|
// dojo.js are already loaded).
|
|
// | // specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
|
|
// | require({
|
|
// | packages:[{
|
|
// | name:"myDojo",
|
|
// | location:".", //assume baseUrl points to dojo.js
|
|
// | }]
|
|
// | });
|
|
// |
|
|
// | // specify a configuration for the myDojo instance
|
|
// | define("myDojo/config", {
|
|
// | // normal configuration variables go here, e.g.,
|
|
// | locale:"fr-ca"
|
|
// | });
|
|
// |
|
|
// | // load and use the new instance of dojo
|
|
// | require(["myDojo"], function(dojo) {
|
|
// | // dojo is the new instance of dojo
|
|
// | // use as required
|
|
// | });
|
|
|
|
var result = {};
|
|
if(1){
|
|
// must be the dojo loader; take a shallow copy of require.rawConfig
|
|
var src = require.rawConfig, p;
|
|
for(p in src){
|
|
result[p] = src[p];
|
|
}
|
|
}else{
|
|
var adviseHas = function(featureSet, prefix, booting){
|
|
for(p in featureSet){
|
|
p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
|
|
}
|
|
};
|
|
result = 1 ?
|
|
// must be a built version of the dojo loader; all config stuffed in require.rawConfig
|
|
require.rawConfig :
|
|
// a foreign loader
|
|
this.dojoConfig || this.djConfig || {};
|
|
adviseHas(result, "config", 1);
|
|
adviseHas(result.has, "", 1);
|
|
}
|
|
return result;
|
|
|
|
/*=====
|
|
// note:
|
|
// 'dojoConfig' 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.
|
|
|
|
// FIXME: can we document these on dojo.config object and explain they must be set via djConfig/dojoConfig global prior to loading dojo.js
|
|
|
|
dojoConfig = {
|
|
// summary:
|
|
// Application code can set the global 'dojoConfig' prior to loading
|
|
// the library to control certain global settings for how dojo works.
|
|
//
|
|
// isDebug: Boolean
|
|
// Defaults to `false`. If set to `true`, ensures that Dojo provides
|
|
// extended debugging feedback via Firebug. If Firebug is not available
|
|
// on your platform, setting `isDebug` to `true` will force Dojo to
|
|
// pull in (and display) the version of Firebug Lite which is
|
|
// integrated into the Dojo distribution, thereby always providing a
|
|
// debugging/logging console when `isDebug` is enabled. Note that
|
|
// Firebug's `console.*` methods are ALWAYS defined by Dojo. If
|
|
// `isDebug` is false and you are on a platform without Firebug, these
|
|
// methods will be defined as no-ops.
|
|
isDebug: false,
|
|
// locale: String
|
|
// The locale to assume for loading localized resources in this page,
|
|
// specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
|
|
// Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
|
|
// See the documentation for `dojo.i18n` and `dojo.requireLocalization`
|
|
// for details on loading localized resources. If no locale is specified,
|
|
// Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
|
|
// or `navigator.language` properties.
|
|
locale: undefined,
|
|
// extraLocale: Array
|
|
// No default value. Specifies additional locales whose
|
|
// resources should also be loaded alongside the default locale when
|
|
// calls to `dojo.requireLocalization()` are processed.
|
|
extraLocale: undefined,
|
|
// baseUrl: String
|
|
// The directory in which `dojo.js` is located. Under normal
|
|
// conditions, Dojo auto-detects the correct location from which it
|
|
// was loaded. You may need to manually configure `baseUrl` in cases
|
|
// where you have renamed `dojo.js` or in which `<base>` tags confuse
|
|
// some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
|
|
// either the value of `djConfig.baseUrl` if one is provided or the
|
|
// auto-detected root if not. Other modules are located relative to
|
|
// this path. The path should end in a slash.
|
|
baseUrl: undefined,
|
|
// modulePaths: Object
|
|
// A map of module names to paths relative to `dojo.baseUrl`. The
|
|
// key/value pairs correspond directly to the arguments which
|
|
// `dojo.registerModulePath` accepts. Specifiying
|
|
// `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
|
|
// of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
|
|
// modules may be configured via `djConfig.modulePaths`.
|
|
modulePaths: {},
|
|
// afterOnLoad: Boolean
|
|
// Indicates Dojo was added to the page after the page load. In this case
|
|
// Dojo will not wait for the page DOMContentLoad/load events and fire
|
|
// its dojo.addOnLoad callbacks after making sure all outstanding
|
|
// dojo.required modules have loaded. Only works with a built dojo.js,
|
|
// it does not work the dojo.js directly from source control.
|
|
afterOnLoad: false,
|
|
// addOnLoad: Function or Array
|
|
// Adds a callback via dojo.addOnLoad. Useful when Dojo is added after
|
|
// the page loads and djConfig.afterOnLoad is true. Supports the same
|
|
// arguments as dojo.addOnLoad. When using a function reference, use
|
|
// `djConfig.addOnLoad = function(){};`. For object with function name use
|
|
// `djConfig.addOnLoad = [myObject, "functionName"];` and for object with
|
|
// function reference use
|
|
// `djConfig.addOnLoad = [myObject, function(){}];`
|
|
addOnLoad: null,
|
|
// require: Array
|
|
// An array of module names to be loaded immediately after dojo.js has been included
|
|
// in a page.
|
|
require: [],
|
|
// defaultDuration: Array
|
|
// Default duration, in milliseconds, for wipe and fade animations within dijits.
|
|
// Assigned to dijit.defaultDuration.
|
|
defaultDuration: 200,
|
|
// dojoBlankHtmlUrl: String
|
|
// Used by some modules to configure an empty iframe. Used by dojo.io.iframe and
|
|
// dojo.back, and dijit popup support in IE where an iframe is needed to make sure native
|
|
// controls do not bleed through the popups. Normally this configuration variable
|
|
// does not need to be set, except when using cross-domain/CDN Dojo builds.
|
|
// Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
|
|
// to the path on your domain your copy of blank.html.
|
|
dojoBlankHtmlUrl: undefined,
|
|
// ioPublish: Boolean?
|
|
// Set this to true to enable publishing of topics for the different phases of
|
|
// IO operations. Publishing is done via dojo.publish. See dojo.__IoPublish for a list
|
|
// of topics that are published.
|
|
ioPublish: false,
|
|
// useCustomLogger: Anything?
|
|
// If set to a value that evaluates to true such as a string or array and
|
|
// isDebug is true and Firebug is not available or running, then it bypasses
|
|
// the creation of Firebug Lite allowing you to define your own console object.
|
|
useCustomLogger: undefined,
|
|
// transparentColor: Array
|
|
// Array containing the r, g, b components used as transparent color in dojo.Color;
|
|
// if undefined, [255,255,255] (white) will be used.
|
|
transparentColor: undefined,
|
|
// skipIeDomLoaded: Boolean
|
|
// For IE only, skip the DOMContentLoaded hack used. Sometimes it can cause an Operation
|
|
// Aborted error if the rest of the page triggers script defers before the DOM is ready.
|
|
// If this is config value is set to true, then dojo.addOnLoad callbacks will not be
|
|
// triggered until the page load event, which is after images and iframes load. If you
|
|
// want to trigger the callbacks sooner, you can put a script block in the bottom of
|
|
// your HTML that calls dojo._loadInit();. If you are using multiversion support, change
|
|
// "dojo." to the appropriate scope name for dojo.
|
|
skipIeDomLoaded: false
|
|
}
|
|
=====*/
|
|
});
|
|
|