this.maxattempts) {
+ var msg = "Over retry limit, giving up";
+ q.timer.cancel();
+ _fail(id, msg);
+ } else {
+ }
+ return;
+ }
+ }
+
+
+ q.timer.cancel();
+ f(id, url);
+
+ }, null, true);
+ } else {
+ lang.later(YAHOO.util.Get.POLL_FREQ, null, f, [id, url]);
+ }
+ }
+ }
+
+ // FireFox and Opera support onload (but not DOM2 in FF) handlers for
+ // script nodes. Opera, but not FF, supports the onload event for link
+ // nodes.
+ } else {
+ n.onload = function() {
+ f(id, url);
+ };
+ }
+ };
+
+ return {
+
+ /**
+ * The default poll freqency in ms, when needed
+ * @property POLL_FREQ
+ * @static
+ * @type int
+ * @default 10
+ */
+ POLL_FREQ: 10,
+
+ /**
+ * The number of request required before an automatic purge.
+ * property PURGE_THRESH
+ * @static
+ * @type int
+ * @default 20
+ */
+ PURGE_THRESH: 20,
+
+ /**
+ * The length time to poll for varName when loading a script in
+ * Safari 2.x before the transaction fails.
+ * property TIMEOUT
+ * @static
+ * @type int
+ * @default 2000
+ */
+ TIMEOUT: 2000,
+
+ /**
+ * Called by the the helper for detecting script load in Safari
+ * @method _finalize
+ * @param id {string} the transaction id
+ * @private
+ */
+ _finalize: function(id) {
+ lang.later(0, null, _finish, id);
+ },
+
+ /**
+ * Abort a transaction
+ * @method abort
+ * @param {string|object} either the tId or the object returned from
+ * script() or css()
+ */
+ abort: function(o) {
+ var id = (lang.isString(o)) ? o : o.tId;
+ var q = queues[id];
+ if (q) {
+ q.aborted = true;
+ }
+ },
+
+ /**
+ * Fetches and inserts one or more script nodes into the head
+ * of the current document or the document in a specified window.
+ *
+ * @method script
+ * @static
+ * @param url {string|string[]} the url or urls to the script(s)
+ * @param opts {object} Options:
+ *
+ * - onSuccess
+ * -
+ * callback to execute when the script(s) are finished loading
+ * The callback receives an object back with the following
+ * data:
+ *
+ * - win
+ * - the window the script(s) were inserted into
+ * - data
+ * - the data object passed in when the request was made
+ * - nodes
+ * - An array containing references to the nodes that were
+ * inserted
+ * - purge
+ * - A function that, when executed, will remove the nodes
+ * that were inserted
+ * -
+ *
+ *
+ * - onFailure
+ * -
+ * callback to execute when the script load operation fails
+ * The callback receives an object back with the following
+ * data:
+ *
+ * - win
+ * - the window the script(s) were inserted into
+ * - data
+ * - the data object passed in when the request was made
+ * - nodes
+ * - An array containing references to the nodes that were
+ * inserted successfully
+ * - purge
+ * - A function that, when executed, will remove any nodes
+ * that were inserted
+ * -
+ *
+ *
+ * - onTimeout
+ * -
+ * callback to execute when a timeout occurs.
+ * The callback receives an object back with the following
+ * data:
+ *
+ * - win
+ * - the window the script(s) were inserted into
+ * - data
+ * - the data object passed in when the request was made
+ * - nodes
+ * - An array containing references to the nodes that were
+ * inserted
+ * - purge
+ * - A function that, when executed, will remove the nodes
+ * that were inserted
+ * -
+ *
+ *
+ * - scope
+ * - the execution context for the callbacks
+ * - win
+ * - a window other than the one the utility occupies
+ * - autopurge
+ * -
+ * setting to true will let the utilities cleanup routine purge
+ * the script once loaded
+ *
+ * - data
+ * -
+ * data that is supplied to the callback when the script(s) are
+ * loaded.
+ *
+ * - varName
+ * -
+ * variable that should be available when a script is finished
+ * loading. Used to help Safari 2.x and below with script load
+ * detection. The type of this property should match what was
+ * passed into the url parameter: if loading a single url, a
+ * string can be supplied. If loading multiple scripts, you
+ * must supply an array that contains the variable name for
+ * each script.
+ *
+ * - insertBefore
+ * - node or node id that will become the new node's nextSibling
+ *
+ * charset
+ * Node charset, default utf-8
+ * timeout
+ * Number of milliseconds to wait before aborting and firing the timeout event
+ *
+ * // assumes yahoo, dom, and event are already on the page
+ * YAHOO.util.Get.script(
+ * ["http://yui.yahooapis.com/2.3.1/build/dragdrop/dragdrop-min.js",
+ * "http://yui.yahooapis.com/2.3.1/build/animation/animation-min.js"], {
+ * onSuccess: function(o) {
+ * new YAHOO.util.DDProxy("dd1"); // also new o.reference("dd1"); would work
+ * this.log("won't cause error because YAHOO is the scope");
+ * this.log(o.nodes.length === 2) // true
+ * // o.purge(); // optionally remove the script nodes immediately
+ * },
+ * onFailure: function(o) {
+ * },
+ * data: "foo",
+ * timeout: 10000, // 10 second timeout
+ * scope: YAHOO,
+ * // win: otherframe // target another window/frame
+ * autopurge: true // allow the utility to choose when to remove the nodes
+ * });
+ *
+ * @return {tId: string} an object containing info about the transaction
+ */
+ script: function(url, opts) { return _queue("script", url, opts); },
+
+ /**
+ * Fetches and inserts one or more css link nodes into the
+ * head of the current document or the document in a specified
+ * window.
+ * @method css
+ * @static
+ * @param url {string} the url or urls to the css file(s)
+ * @param opts Options:
+ *
+ * - onSuccess
+ * -
+ * callback to execute when the css file(s) are finished loading
+ * The callback receives an object back with the following
+ * data:
+ *
win
+ * - the window the link nodes(s) were inserted into
+ * - data
+ * - the data object passed in when the request was made
+ * - nodes
+ * - An array containing references to the nodes that were
+ * inserted
+ * - purge
+ * - A function that, when executed, will remove the nodes
+ * that were inserted
+ * -
+ *
+ *
+ * scope
+ * the execution context for the callbacks
+ * win
+ * a window other than the one the utility occupies
+ * data
+ *
+ * data that is supplied to the callbacks when the nodes(s) are
+ * loaded.
+ *
+ * insertBefore
+ * node or node id that will become the new node's nextSibling
+ * charset
+ * Node charset, default utf-8
+ *
+ *
+ * YAHOO.util.Get.css("http://yui.yahooapis.com/2.3.1/build/menu/assets/skins/sam/menu.css");
+ *
+ *
+ * YAHOO.util.Get.css(["http://yui.yahooapis.com/2.3.1/build/menu/assets/skins/sam/menu.css",
+ *
+ * @return {tId: string} an object containing info about the transaction
+ */
+ css: function(url, opts) {
+ return _queue("css", url, opts);
+ }
+ };
+}();
+
+YAHOO.register("get", YAHOO.util.Get, {version: "2.7.0", build: "1799"});
+/**
+ * Provides dynamic loading for the YUI library. It includes the dependency
+ * info for the library, and will automatically pull in dependencies for
+ * the modules requested. It supports rollup files (such as utilities.js
+ * and yahoo-dom-event.js), and will automatically use these when
+ * appropriate in order to minimize the number of http connections
+ * required to load all of the dependencies.
+ *
+ * @module yuiloader
+ * @namespace YAHOO.util
+ */
+
+/**
+ * YUILoader provides dynamic loading for YUI.
+ * @class YAHOO.util.YUILoader
+ * @todo
+ * version management, automatic sandboxing
+ */
+(function() {
+
+ var Y=YAHOO, util=Y.util, lang=Y.lang, env=Y.env,
+ PROV = "_provides", SUPER = "_supersedes",
+ REQ = "expanded", AFTER = "_after";
+
+ var YUI = {
+
+ dupsAllowed: {'yahoo': true, 'get': true},
+
+ /*
+ * The library metadata for the current release The is the default
+ * value for YAHOO.util.YUILoader.moduleInfo
+ * @property YUIInfo
+ * @static
+ */
+ info: {
+
+ // 'root': '2.5.2/build/',
+ // 'base': 'http://yui.yahooapis.com/2.5.2/build/',
+
+ 'root': '2.7.0/build/',
+ 'base': 'http://yui.yahooapis.com/2.7.0/build/',
+
+ 'comboBase': 'http://yui.yahooapis.com/combo?',
+
+ 'skin': {
+ 'defaultSkin': 'sam',
+ 'base': 'assets/skins/',
+ 'path': 'skin.css',
+ 'after': ['reset', 'fonts', 'grids', 'base'],
+ 'rollup': 3
+ },
+
+ dupsAllowed: ['yahoo', 'get'],
+
+ 'moduleInfo': {
+
+ 'animation': {
+ 'type': 'js',
+ 'path': 'animation/animation-min.js',
+ 'requires': ['dom', 'event']
+ },
+
+ 'autocomplete': {
+ 'type': 'js',
+ 'path': 'autocomplete/autocomplete-min.js',
+ 'requires': ['dom', 'event', 'datasource'],
+ 'optional': ['connection', 'animation'],
+ 'skinnable': true
+ },
+
+ 'base': {
+ 'type': 'css',
+ 'path': 'base/base-min.css',
+ 'after': ['reset', 'fonts', 'grids']
+ },
+
+ 'button': {
+ 'type': 'js',
+ 'path': 'button/button-min.js',
+ 'requires': ['element'],
+ 'optional': ['menu'],
+ 'skinnable': true
+ },
+
+ 'calendar': {
+ 'type': 'js',
+ 'path': 'calendar/calendar-min.js',
+ 'requires': ['event', 'dom'],
+ 'skinnable': true
+ },
+
+ 'carousel': {
+ 'type': 'js',
+ 'path': 'carousel/carousel-min.js',
+ 'requires': ['element'],
+ 'optional': ['animation'],
+ 'skinnable': true
+ },
+
+ 'charts': {
+ 'type': 'js',
+ 'path': 'charts/charts-min.js',
+ 'requires': ['element', 'json', 'datasource']
+ },
+
+ 'colorpicker': {
+ 'type': 'js',
+ 'path': 'colorpicker/colorpicker-min.js',
+ 'requires': ['slider', 'element'],
+ 'optional': ['animation'],
+ 'skinnable': true
+ },
+
+ 'connection': {
+ 'type': 'js',
+ 'path': 'connection/connection-min.js',
+ 'requires': ['event']
+ },
+
+ 'container': {
+ 'type': 'js',
+ 'path': 'container/container-min.js',
+ 'requires': ['dom', 'event'],
+ // button is also optional, but this creates a circular
+ // dependency when loadOptional is specified. button
+ // optionally includes menu, menu requires container.
+ 'optional': ['dragdrop', 'animation', 'connection'],
+ 'supersedes': ['containercore'],
+ 'skinnable': true
+ },
+
+ 'containercore': {
+ 'type': 'js',
+ 'path': 'container/container_core-min.js',
+ 'requires': ['dom', 'event'],
+ 'pkg': 'container'
+ },
+
+ 'cookie': {
+ 'type': 'js',
+ 'path': 'cookie/cookie-min.js',
+ 'requires': ['yahoo']
+ },
+
+ 'datasource': {
+ 'type': 'js',
+ 'path': 'datasource/datasource-min.js',
+ 'requires': ['event'],
+ 'optional': ['connection']
+ },
+
+ 'datatable': {
+ 'type': 'js',
+ 'path': 'datatable/datatable-min.js',
+ 'requires': ['element', 'datasource'],
+ 'optional': ['calendar', 'dragdrop', 'paginator'],
+ 'skinnable': true
+ },
+
+ 'dom': {
+ 'type': 'js',
+ 'path': 'dom/dom-min.js',
+ 'requires': ['yahoo']
+ },
+
+ 'dragdrop': {
+ 'type': 'js',
+ 'path': 'dragdrop/dragdrop-min.js',
+ 'requires': ['dom', 'event']
+ },
+
+ 'editor': {
+ 'type': 'js',
+ 'path': 'editor/editor-min.js',
+ 'requires': ['menu', 'element', 'button'],
+ 'optional': ['animation', 'dragdrop'],
+ 'supersedes': ['simpleeditor'],
+ 'skinnable': true
+ },
+
+ 'element': {
+ 'type': 'js',
+ 'path': 'element/element-min.js',
+ 'requires': ['dom', 'event']
+ },
+
+ 'event': {
+ 'type': 'js',
+ 'path': 'event/event-min.js',
+ 'requires': ['yahoo']
+ },
+
+ 'fonts': {
+ 'type': 'css',
+ 'path': 'fonts/fonts-min.css'
+ },
+
+ 'get': {
+ 'type': 'js',
+ 'path': 'get/get-min.js',
+ 'requires': ['yahoo']
+ },
+
+ 'grids': {
+ 'type': 'css',
+ 'path': 'grids/grids-min.css',
+ 'requires': ['fonts'],
+ 'optional': ['reset']
+ },
+
+ 'history': {
+ 'type': 'js',
+ 'path': 'history/history-min.js',
+ 'requires': ['event']
+ },
+
+ 'imagecropper': {
+ 'type': 'js',
+ 'path': 'imagecropper/imagecropper-min.js',
+ 'requires': ['dom', 'event', 'dragdrop', 'element', 'resize'],
+ 'skinnable': true
+ },
+
+ 'imageloader': {
+ 'type': 'js',
+ 'path': 'imageloader/imageloader-min.js',
+ 'requires': ['event', 'dom']
+ },
+
+ 'json': {
+ 'type': 'js',
+ 'path': 'json/json-min.js',
+ 'requires': ['yahoo']
+ },
+
+ 'layout': {
+ 'type': 'js',
+ 'path': 'layout/layout-min.js',
+ 'requires': ['dom', 'event', 'element'],
+ 'optional': ['animation', 'dragdrop', 'resize', 'selector'],
+ 'skinnable': true
+ },
+
+ 'logger': {
+ 'type': 'js',
+ 'path': 'logger/logger-min.js',
+ 'requires': ['event', 'dom'],
+ 'optional': ['dragdrop'],
+ 'skinnable': true
+ },
+
+ 'menu': {
+ 'type': 'js',
+ 'path': 'menu/menu-min.js',
+ 'requires': ['containercore'],
+ 'skinnable': true
+ },
+
+ 'paginator': {
+ 'type': 'js',
+ 'path': 'paginator/paginator-min.js',
+ 'requires': ['element'],
+ 'skinnable': true
+ },
+
+ 'profiler': {
+ 'type': 'js',
+ 'path': 'profiler/profiler-min.js',
+ 'requires': ['yahoo']
+ },
+
+
+ 'profilerviewer': {
+ 'type': 'js',
+ 'path': 'profilerviewer/profilerviewer-min.js',
+ 'requires': ['profiler', 'yuiloader', 'element'],
+ 'skinnable': true
+ },
+
+ 'reset': {
+ 'type': 'css',
+ 'path': 'reset/reset-min.css'
+ },
+
+ 'reset-fonts-grids': {
+ 'type': 'css',
+ 'path': 'reset-fonts-grids/reset-fonts-grids.css',
+ 'supersedes': ['reset', 'fonts', 'grids', 'reset-fonts'],
+ 'rollup': 4
+ },
+
+ 'reset-fonts': {
+ 'type': 'css',
+ 'path': 'reset-fonts/reset-fonts.css',
+ 'supersedes': ['reset', 'fonts'],
+ 'rollup': 2
+ },
+
+ 'resize': {
+ 'type': 'js',
+ 'path': 'resize/resize-min.js',
+ 'requires': ['dom', 'event', 'dragdrop', 'element'],
+ 'optional': ['animation'],
+ 'skinnable': true
+ },
+
+ 'selector': {
+ 'type': 'js',
+ 'path': 'selector/selector-min.js',
+ 'requires': ['yahoo', 'dom']
+ },
+
+ 'simpleeditor': {
+ 'type': 'js',
+ 'path': 'editor/simpleeditor-min.js',
+ 'requires': ['element'],
+ 'optional': ['containercore', 'menu', 'button', 'animation', 'dragdrop'],
+ 'skinnable': true,
+ 'pkg': 'editor'
+ },
+
+ 'slider': {
+ 'type': 'js',
+ 'path': 'slider/slider-min.js',
+ 'requires': ['dragdrop'],
+ 'optional': ['animation'],
+ 'skinnable': true
+ },
+
+ 'stylesheet': {
+ 'type': 'js',
+ 'path': 'stylesheet/stylesheet-min.js',
+ 'requires': ['yahoo']
+ },
+
+ 'tabview': {
+ 'type': 'js',
+ 'path': 'tabview/tabview-min.js',
+ 'requires': ['element'],
+ 'optional': ['connection'],
+ 'skinnable': true
+ },
+
+ 'treeview': {
+ 'type': 'js',
+ 'path': 'treeview/treeview-min.js',
+ 'requires': ['event', 'dom'],
+ 'optional': ['json'],
+ 'skinnable': true
+ },
+
+ 'uploader': {
+ 'type': 'js',
+ 'path': 'uploader/uploader.js',
+ 'requires': ['element']
+ },
+
+ 'utilities': {
+ 'type': 'js',
+ 'path': 'utilities/utilities.js',
+ 'supersedes': ['yahoo', 'event', 'dragdrop', 'animation', 'dom', 'connection', 'element', 'yahoo-dom-event', 'get', 'yuiloader', 'yuiloader-dom-event'],
+ 'rollup': 8
+ },
+
+ 'yahoo': {
+ 'type': 'js',
+ 'path': 'yahoo/yahoo-min.js'
+ },
+
+ 'yahoo-dom-event': {
+ 'type': 'js',
+ 'path': 'yahoo-dom-event/yahoo-dom-event.js',
+ 'supersedes': ['yahoo', 'event', 'dom'],
+ 'rollup': 3
+ },
+
+ 'yuiloader': {
+ 'type': 'js',
+ 'path': 'yuiloader/yuiloader-min.js',
+ 'supersedes': ['yahoo', 'get']
+ },
+
+ 'yuiloader-dom-event': {
+ 'type': 'js',
+ 'path': 'yuiloader-dom-event/yuiloader-dom-event.js',
+ 'supersedes': ['yahoo', 'dom', 'event', 'get', 'yuiloader', 'yahoo-dom-event'],
+ 'rollup': 5
+ },
+
+ 'yuitest': {
+ 'type': 'js',
+ 'path': 'yuitest/yuitest-min.js',
+ 'requires': ['logger'],
+ 'skinnable': true
+ }
+ }
+}
+ ,
+
+ ObjectUtil: {
+ appendArray: function(o, a) {
+ if (a) {
+ for (var i=0; i
+ * DEBUG
+ * Selects the debug versions of the library (e.g., event-debug.js).
+ * This option will automatically include the logger widget
+ * RAW
+ * Selects the non-minified version of the library (e.g., event.js).
+ *
+ * You can also define a custom filter, which must be an object literal
+ * containing a search expression and a replace string:
+ *
+ * myFilter: {
+ * 'searchExp': "-min\\.js",
+ * 'replaceStr': "-debug.js"
+ * }
+ *
+ * @property filter
+ * @type string|{searchExp: string, replaceStr: string}
+ */
+ this.filter = null;
+
+ /**
+ * The list of requested modules
+ * @property required
+ * @type {string: boolean}
+ */
+ this.required = {};
+
+ /**
+ * The library metadata
+ * @property moduleInfo
+ */
+ this.moduleInfo = lang.merge(YUI.info.moduleInfo);
+
+ /**
+ * List of rollup files found in the library metadata
+ * @property rollups
+ */
+ this.rollups = null;
+
+ /**
+ * Whether or not to load optional dependencies for
+ * the requested modules
+ * @property loadOptional
+ * @type boolean
+ * @default false
+ */
+ this.loadOptional = false;
+
+ /**
+ * All of the derived dependencies in sorted order, which
+ * will be populated when either calculate() or insert()
+ * is called
+ * @property sorted
+ * @type string[]
+ */
+ this.sorted = [];
+
+ /**
+ * Set when beginning to compute the dependency tree.
+ * Composed of what YAHOO reports to be loaded combined
+ * with what has been loaded by the tool
+ * @propery loaded
+ * @type {string: boolean}
+ */
+ this.loaded = {};
+
+ /**
+ * Flag to indicate the dependency tree needs to be recomputed
+ * if insert is called again.
+ * @property dirty
+ * @type boolean
+ * @default true
+ */
+ this.dirty = true;
+
+ /**
+ * List of modules inserted by the utility
+ * @property inserted
+ * @type {string: boolean}
+ */
+ this.inserted = {};
+
+ /**
+ * Provides the information used to skin the skinnable components.
+ * The following skin definition would result in 'skin1' and 'skin2'
+ * being loaded for calendar (if calendar was requested), and
+ * 'sam' for all other skinnable components:
+ *
+ *
+ * skin: {
+ *
+ * // The default skin, which is automatically applied if not
+ * // overriden by a component-specific skin definition.
+ * // Change this in to apply a different skin globally
+ * defaultSkin: 'sam',
+ *
+ * // This is combined with the loader base property to get
+ * // the default root directory for a skin. ex:
+ * // http://yui.yahooapis.com/2.3.0/build/assets/skins/sam/
+ * base: 'assets/skins/',
+ *
+ * // The name of the rollup css file for the skin
+ * path: 'skin.css',
+ *
+ * // The number of skinnable components requested that are
+ * // required before using the rollup file rather than the
+ * // individual component css files
+ * rollup: 3,
+ *
+ * // Any component-specific overrides can be specified here,
+ * // making it possible to load different skins for different
+ * // components. It is possible to load more than one skin
+ * // for a given component as well.
+ * overrides: {
+ * calendar: ['skin1', 'skin2']
+ * }
+ * }
+ *
+ * @property skin
+ */
+
+ var self = this;
+
+ env.listeners.push(function(m) {
+ if (self._useYahooListener) {
+ //Y.log("YAHOO listener: " + m.name);
+ self.loadNext(m.name);
+ }
+ });
+
+ this.skin = lang.merge(YUI.info.skin);
+
+ this._config(o);
+
+ };
+
+ Y.util.YUILoader.prototype = {
+
+ FILTERS: {
+ RAW: {
+ 'searchExp': "-min\\.js",
+ 'replaceStr': ".js"
+ },
+ DEBUG: {
+ 'searchExp': "-min\\.js",
+ 'replaceStr': "-debug.js"
+ }
+ },
+
+ SKIN_PREFIX: "skin-",
+
+ _config: function(o) {
+
+ // apply config values
+ if (o) {
+ for (var i in o) {
+ if (lang.hasOwnProperty(o, i)) {
+ if (i == "require") {
+ this.require(o[i]);
+ } else {
+ this[i] = o[i];
+ }
+ }
+ }
+ }
+
+ // fix filter
+ var f = this.filter;
+
+ if (lang.isString(f)) {
+ f = f.toUpperCase();
+
+ // the logger must be available in order to use the debug
+ // versions of the library
+ if (f === "DEBUG") {
+ this.require("logger");
+ }
+
+ // hack to handle a a bug where LogWriter is being instantiated
+ // at load time, and the loader has no way to sort above it
+ // at the moment.
+ if (!Y.widget.LogWriter) {
+ Y.widget.LogWriter = function() {
+ return Y;
+ };
+ }
+
+ this.filter = this.FILTERS[f];
+ }
+
+ },
+
+ /** Add a new module to the component metadata.
+ *
+ * - name:
- required, the component name
+ * - type:
- required, the component type (js or css)
+ * - path:
- required, the path to the script from "base"
+ * - requires:
- array of modules required by this component
+ * - optional:
- array of optional modules for this component
+ * - supersedes:
- array of the modules this component replaces
+ * - after:
- array of modules the components which, if present, should be sorted above this one
+ * - rollup:
- the number of superseded modules required for automatic rollup
+ * - fullpath:
- If fullpath is specified, this is used instead of the configured base + path
+ * - skinnable:
- flag to determine if skin assets should automatically be pulled in
+ *
+ * @method addModule
+ * @param o An object containing the module data
+ * @return {boolean} true if the module was added, false if
+ * the object passed in did not provide all required attributes
+ */
+ addModule: function(o) {
+
+ if (!o || !o.name || !o.type || (!o.path && !o.fullpath)) {
+ return false;
+ }
+
+ o.ext = ('ext' in o) ? o.ext : true;
+ o.requires = o.requires || [];
+
+ this.moduleInfo[o.name] = o;
+ this.dirty = true;
+
+ return true;
+ },
+
+ /**
+ * Add a requirement for one or more module
+ * @method require
+ * @param what {string[] | string*} the modules to load
+ */
+ require: function(what) {
+ var a = (typeof what === "string") ? arguments : what;
+ this.dirty = true;
+ YUI.ObjectUtil.appendArray(this.required, a);
+ },
+
+ /**
+ * Adds the skin def to the module info
+ * @method _addSkin
+ * @param skin {string} the name of the skin
+ * @param mod {string} the name of the module
+ * @return {string} the module name for the skin
+ * @private
+ */
+ _addSkin: function(skin, mod) {
+
+ // Add a module definition for the skin rollup css
+ var name = this.formatSkin(skin), info = this.moduleInfo,
+ sinf = this.skin, ext = info[mod] && info[mod].ext;
+
+ // Y.log('ext? ' + mod + ": " + ext);
+ if (!info[name]) {
+ // Y.log('adding skin ' + name);
+ this.addModule({
+ 'name': name,
+ 'type': 'css',
+ 'path': sinf.base + skin + '/' + sinf.path,
+ //'supersedes': '*',
+ 'after': sinf.after,
+ 'rollup': sinf.rollup,
+ 'ext': ext
+ });
+ }
+
+ // Add a module definition for the module-specific skin css
+ if (mod) {
+ name = this.formatSkin(skin, mod);
+ if (!info[name]) {
+ var mdef = info[mod], pkg = mdef.pkg || mod;
+ // Y.log('adding skin ' + name);
+ this.addModule({
+ 'name': name,
+ 'type': 'css',
+ 'after': sinf.after,
+ 'path': pkg + '/' + sinf.base + skin + '/' + mod + '.css',
+ 'ext': ext
+ });
+ }
+ }
+
+ return name;
+ },
+
+ /**
+ * Returns an object containing properties for all modules required
+ * in order to load the requested module
+ * @method getRequires
+ * @param mod The module definition from moduleInfo
+ */
+ getRequires: function(mod) {
+ if (!mod) {
+ return [];
+ }
+
+ if (!this.dirty && mod.expanded) {
+ return mod.expanded;
+ }
+
+ mod.requires=mod.requires || [];
+ var i, d=[], r=mod.requires, o=mod.optional, info=this.moduleInfo, m;
+ for (i=0; i -1) {
+ // // YAHOO.log('adding ' + r[j]);
+ // d.push(req[j]);
+ // }
+ // }
+ // }
+ }
+
+ if (o && this.loadOptional) {
+ for (i=0; iformatSkin, providing the skin name and
+ * module name if the string matches the pattern for skins.
+ * @method parseSkin
+ * @param mod {string} the module name to parse
+ * @return {skin: string, module: string} the parsed skin name
+ * and module name, or null if the supplied string does not match
+ * the skin pattern
+ */
+ parseSkin: function(mod) {
+
+ if (mod.indexOf(this.SKIN_PREFIX) === 0) {
+ var a = mod.split("-");
+ return {skin: a[1], module: a[2]};
+ }
+
+ return null;
+ },
+
+ /**
+ * Look for rollup packages to determine if all of the modules a
+ * rollup supersedes are required. If so, include the rollup to
+ * help reduce the total number of connections required. Called
+ * by calculate()
+ * @method _rollup
+ * @private
+ */
+ _rollup: function() {
+ var i, j, m, s, rollups={}, r=this.required, roll,
+ info = this.moduleInfo;
+
+ // find and cache rollup modules
+ if (this.dirty || !this.rollups) {
+ for (i in info) {
+ if (lang.hasOwnProperty(info, i)) {
+ m = info[i];
+ //if (m && m.rollup && m.supersedes) {
+ if (m && m.rollup) {
+ rollups[i] = m;
+ }
+ }
+ }
+
+ this.rollups = rollups;
+ }
+
+ // make as many passes as needed to pick up rollup rollups
+ for (;;) {
+ var rolled = false;
+
+ // go through the rollup candidates
+ for (i in rollups) {
+
+ // there can be only one
+ if (!r[i] && !this.loaded[i]) {
+ m =info[i]; s = m.supersedes; roll=false;
+
+ if (!m.rollup) {
+ continue;
+ }
+
+ var skin = (m.ext) ? false : this.parseSkin(i), c = 0;
+
+ // Y.log('skin? ' + i + ": " + skin);
+ if (skin) {
+ for (j in r) {
+ if (lang.hasOwnProperty(r, j)) {
+ if (i !== j && this.parseSkin(j)) {
+ c++;
+ roll = (c >= m.rollup);
+ if (roll) {
+ // Y.log("skin rollup " + lang.dump(r));
+ break;
+ }
+ }
+ }
+ }
+
+ } else {
+
+ // check the threshold
+ for (j=0;j= m.rollup);
+ if (roll) {
+ // Y.log("over thresh " + c + ", " + lang.dump(r));
+ break;
+ }
+ }
+ }
+ }
+
+ if (roll) {
+ // Y.log("rollup: " + i + ", " + lang.dump(this, 1));
+ // add the rollup
+ r[i] = true;
+ rolled = true;
+
+ // expand the rollup's dependencies
+ this.getRequires(m);
+ }
+ }
+ }
+
+ // if we made it here w/o rolling up something, we are done
+ if (!rolled) {
+ break;
+ }
+ }
+ },
+
+ /**
+ * Remove superceded modules and loaded modules. Called by
+ * calculate() after we have the mega list of all dependencies
+ * @method _reduce
+ * @private
+ */
+ _reduce: function() {
+
+ var i, j, s, m, r=this.required;
+ for (i in r) {
+
+ // remove if already loaded
+ if (i in this.loaded) {
+ delete r[i];
+
+ // remove anything this module supersedes
+ } else {
+
+ var skinDef = this.parseSkin(i);
+
+ if (skinDef) {
+ //YAHOO.log("skin found in reduce: " + skinDef.skin + ", " + skinDef.module);
+ // the skin rollup will not have a module name
+ if (!skinDef.module) {
+ var skin_pre = this.SKIN_PREFIX + skinDef.skin;
+ //YAHOO.log("skin_pre: " + skin_pre);
+ for (j in r) {
+
+ if (lang.hasOwnProperty(r, j)) {
+ m = this.moduleInfo[j];
+ var ext = m && m.ext;
+ if (!ext && j !== i && j.indexOf(skin_pre) > -1) {
+ // Y.log ("removing component skin: " + j);
+ delete r[j];
+ }
+ }
+ }
+ }
+ } else {
+
+ m = this.moduleInfo[i];
+ s = m && m.supersedes;
+ if (s) {
+ for (j=0; j -1) {
+ return true;
+ }
+
+ // check if this module should be sorted after the other
+ if (after && YUI.ArrayUtil.indexOf(after, bb) > -1) {
+ return true;
+ }
+
+ // if loadOptional is not specified, optional dependencies still
+ // must be sorted correctly when present.
+ if (checkOptional && optional && YUI.ArrayUtil.indexOf(optional, bb) > -1) {
+ return true;
+ }
+
+ // check if this module requires one the other supersedes
+ var ss=info[bb] && info[bb].supersedes;
+ if (ss) {
+ for (ii=0; ii startLen) {
+ YAHOO.util.Get.script(self._filter(js), {
+ data: self._loading,
+ onSuccess: callback,
+ onFailure: self._onFailure,
+ onTimeout: self._onTimeout,
+ insertBefore: self.insertBefore,
+ charset: self.charset,
+ timeout: self.timeout,
+ scope: self
+ });
+ }
+ };
+
+ // load the css first
+ // YAHOO.log('combining css: ' + css);
+ if (css.length > startLen) {
+ YAHOO.util.Get.css(this._filter(css), {
+ data: this._loading,
+ onSuccess: loadScript,
+ onFailure: this._onFailure,
+ onTimeout: this._onTimeout,
+ insertBefore: this.insertBefore,
+ charset: this.charset,
+ timeout: this.timeout,
+ scope: self
+ });
+ } else {
+ loadScript();
+ }
+
+ return;
+
+ } else {
+ // this._combineComplete = true;
+ this.loadNext(this._loading);
+ }
+ },
+
+ /**
+ * inserts the requested modules and their dependencies.
+ * type can be "js" or "css". Both script and
+ * css are inserted if type is not provided.
+ * @method insert
+ * @param o optional options object
+ * @param type {string} the type of dependency to insert
+ */
+ insert: function(o, type) {
+ // if (o) {
+ // Y.log("insert: " + lang.dump(o, 1) + ", " + type);
+ // } else {
+ // Y.log("insert: " + this.toString() + ", " + type);
+ // }
+
+ // build the dependency list
+ this.calculate(o);
+
+
+ // set a flag to indicate the load has started
+ this._loading = true;
+
+ // flag to indicate we are done with the combo service
+ // and any additional files will need to be loaded
+ // individually
+ // this._combineComplete = false;
+
+ // keep the loadType (js, css or undefined) cached
+ this.loadType = type;
+
+ if (this.combine) {
+ return this._combine();
+ }
+
+ if (!type) {
+ // Y.log("trying to load css first");
+ var self = this;
+ this._internalCallback = function() {
+ self._internalCallback = null;
+ self.insert(null, "js");
+ };
+ this.insert(null, "css");
+ return;
+ }
+
+
+ // start the load
+ this.loadNext();
+
+ },
+
+ /**
+ * Interns the script for the requested modules. The callback is
+ * provided a reference to the sandboxed YAHOO object. This only
+ * applies to the script: css can not be sandboxed; css will be
+ * loaded into the page normally if specified.
+ * @method sandbox
+ * @param callback {Function} the callback to exectued when the load is
+ * complete.
+ */
+ sandbox: function(o, type) {
+ // if (o) {
+ // YAHOO.log("sandbox: " + lang.dump(o, 1) + ", " + type);
+ // } else {
+ // YAHOO.log("sandbox: " + this.toString() + ", " + type);
+ // }
+
+ this._config(o);
+
+ if (!this.onSuccess) {
+throw new Error("You must supply an onSuccess handler for your sandbox");
+ }
+
+ this._sandbox = true;
+
+ var self = this;
+
+ // take care of any css first (this can't be sandboxed)
+ if (!type || type !== "js") {
+ this._internalCallback = function() {
+ self._internalCallback = null;
+ self.sandbox(null, "js");
+ };
+ this.insert(null, "css");
+ return;
+ }
+
+ // get the connection manager if not on the page
+ if (!util.Connect) {
+ // get a new loader instance to load connection.
+ var ld = new YAHOO.util.YUILoader();
+ ld.insert({
+ base: this.base,
+ filter: this.filter,
+ require: "connection",
+ insertBefore: this.insertBefore,
+ charset: this.charset,
+ onSuccess: function() {
+ this.sandbox(null, "js");
+ },
+ scope: this
+ }, "js");
+ return;
+ }
+
+ this._scriptText = [];
+ this._loadCount = 0;
+ this._stopCount = this.sorted.length;
+ this._xhr = [];
+
+ this.calculate();
+
+ var s=this.sorted, l=s.length, i, m, url;
+
+ for (i=0; i= this._stopCount) {
+
+ // the variable to find
+ var v = this.varName || "YAHOO";
+
+ // wrap the contents of the requested modules in an anonymous function
+ var t = "(function() {\n";
+
+ // return the locally scoped reference.
+ var b = "\nreturn " + v + ";\n})();";
+
+ var ref = eval(t + this._scriptText.join("\n") + b);
+
+ this._pushEvents(ref);
+
+ if (ref) {
+ this.onSuccess.call(this.scope, {
+ reference: ref,
+ data: this.data
+ });
+ } else {
+ this._onFailure.call(this.varName + " reference failure");
+ }
+ }
+ },
+
+ failure: function(o) {
+ this.onFailure.call(this.scope, {
+ msg: "XHR failure",
+ xhrResponse: o,
+ data: this.data
+ });
+ },
+
+ scope: this,
+
+ // module index, module name, sandbox name
+ argument: [i, url, s[i]]
+
+ };
+
+ this._xhr.push(util.Connect.asyncRequest('GET', url, xhrData));
+ }
+ },
+
+ /**
+ * Executed every time a module is loaded, and if we are in a load
+ * cycle, we attempt to load the next script. Public so that it
+ * is possible to call this if using a method other than
+ * YAHOO.register to determine when scripts are fully loaded
+ * @method loadNext
+ * @param mname {string} optional the name of the module that has
+ * been loaded (which is usually why it is time to load the next
+ * one)
+ */
+ loadNext: function(mname) {
+
+ // It is possible that this function is executed due to something
+ // else one the page loading a YUI module. Only react when we
+ // are actively loading something
+ if (!this._loading) {
+ return;
+ }
+
+
+ if (mname) {
+
+ // if the module that was just loaded isn't what we were expecting,
+ // continue to wait
+ if (mname !== this._loading) {
+ return;
+ }
+
+ // YAHOO.log("loadNext executing, just loaded " + mname);
+
+ // The global handler that is called when each module is loaded
+ // will pass that module name to this function. Storing this
+ // data to avoid loading the same module multiple times
+ this.inserted[mname] = true;
+
+ if (this.onProgress) {
+ this.onProgress.call(this.scope, {
+ name: mname,
+ data: this.data
+ });
+ }
+ //var o = this.getProvides(mname);
+ //this.inserted = lang.merge(this.inserted, o);
+ }
+
+ var s=this.sorted, len=s.length, i, m;
+
+ for (i=0; i