Revision 5a79356b

View differences:

src/sunstone/public/app/main.js
1
require.config({
2
  paths: {
3
    /* jQuery */
4
    'jquery': '../bower_components/jquery/dist/jquery.min',
5

  
6
    /* Foundation */
7
    'foundation.core': '../bower_components/foundation/js/foundation/foundation',
8
    'foundation.abide': '../bower_components/foundation/js/foundation/foundation.abide',
9
    'foundation.accordion': '../bower_components/foundation/js/foundation/foundation.accordion',
10
    'foundation.alert': '../bower_components/foundation/js/foundation/foundation.alert',
11
    'foundation.clearing': '../bower_components/foundation/js/foundation/foundation.clearing',
12
    'foundation.dropdown': '../bower_components/foundation/js/foundation/foundation.dropdown',
13
    'foundation.equalizer': '../bower_components/foundation/js/foundation/foundation.equalizer',
14
    'foundation.interchange': '../bower_components/foundation/js/foundation/foundation.interchange',
15
    'foundation.joyride': '../bower_components/foundation/js/foundation/foundation.joyride',
16
    'foundation.magellan': '../bower_components/foundation/js/foundation/foundation.magellan',
17
    'foundation.offcanvas': '../bower_components/foundation/js/foundation/foundation.offcanvas',
18
    'foundation.orbit': '../bower_components/foundation/js/foundation/foundation.orbit',
19
    'foundation.reveal': '../bower_components/foundation/js/foundation/foundation.reveal',
20
    'foundation.tab': '../bower_components/foundation/js/foundation/foundation.tab',
21
    'foundation.tooltip': '../bower_components/foundation/js/foundation/foundation.tooltip',
22
    'foundation.topbar': '../bower_components/foundation/js/foundation/foundation.topbar',
23

  
24
    /* Handlebars */
25
    'hbs': '../bower_components/require-handlebars-plugin/hbs',
26

  
27
    /* Vendor Scripts */
28
    'jquery.cookie': '../bower_components/foundation/js/vendor/jquery.cookie',
29
    'fastclick': '../bower_components/foundation/js/vendor/fastclick',
30
    'modernizr': '../bower_components/foundation/js/vendor/modernizr',
31
    'placeholder': '../bower_components/foundation/js/vendor/placeholder'
32
  },
33
  shim: {
34
    /* jQuery */
35
    'jquery': {
36
      exports: '$'
37
    },
38

  
39
    /* Foundation */
40
    'foundation.core': {
41
      deps: ['jquery', 'modernizr'],
42
      exports: 'Foundation'
43
    },
44
    'foundation.abide': {
45
      deps: ['foundation.core']
46
    },
47
    'foundation.accordion': {
48
      deps: ['foundation.core']
49
    },
50
    'foundation.alert': {
51
      deps: ['foundation.core']
52
    },
53
    'foundation.clearing': {
54
      deps: ['foundation.core']
55
    },
56
    'foundation.dropdown': {
57
      deps: ['foundation.core']
58
    },
59
    'foundation.equalizer': {
60
      deps: ['foundation.core']
61
    },
62
    'foundation.interchange': {
63
      deps: ['foundation.core']
64
    },
65
    'foundation.joyride': {
66
      deps: ['foundation.core', 'foundation.cookie']
67
    },
68
    'foundation.magellan': {
69
      deps: ['foundation.core']
70
    },
71
    'foundation.offcanvas': {
72
      deps: ['foundation.core']
73
    },
74
    'foundation.orbit': {
75
      deps: ['foundation.core']
76
    },
77
    'foundation.reveal': {
78
      deps: ['foundation.core']
79
    },
80
    'foundation.tab': {
81
      deps: ['foundation.core']
82
    },
83
    'foundation.tooltip': {
84
      deps: ['foundation.core']
85
    },
86
    'foundation.topbar': {
87
      deps: ['foundation.core']
88
    },
89

  
90
    /* Vendor Scripts */
91
    'jquery.cookie': {
92
      deps: ['jquery']
93
    },
94
    'fastclick': {
95
      exports: 'FastClick'
96
    },
97
    'modernizr': {
98
      exports: 'Modernizr'
99
    },
100
    'placeholder': {
101
      exports: 'Placeholders'
102
    }
103
  }
104
});
105

  
106
require(['app'], function(App) {});
src/sunstone/public/bower.json
11 11
    "flot.tooltip": "latest",
12 12
    "no-vnc": "*",
13 13
    "resumablejs": "*",
14
    "spice-html5": "git://anongit.freedesktop.org/spice/spice-html5"
14
    "spice-html5": "git://anongit.freedesktop.org/spice/spice-html5",
15
    "requirejs": "~2.1.17"
15 16
  }
16 17
}
src/sunstone/public/bower_components/requirejs/.bower.json
1
{
2
  "name": "requirejs",
3
  "version": "2.1.17",
4
  "homepage": "http://requirejs.org",
5
  "authors": [
6
    "jrburke.com"
7
  ],
8
  "description": "A file and module loader for JavaScript",
9
  "main": "require.js",
10
  "keywords": [
11
    "AMD"
12
  ],
13
  "license": "new BSD, and MIT",
14
  "_release": "2.1.17",
15
  "_resolution": {
16
    "type": "version",
17
    "tag": "2.1.17",
18
    "commit": "72b4505d30d9fa342f6dc88ee25da2b2da6a1e58"
19
  },
20
  "_source": "git://github.com/jrburke/requirejs-bower.git",
21
  "_target": "~2.1.17",
22
  "_originalSource": "requirejs",
23
  "_direct": true
24
}
src/sunstone/public/bower_components/requirejs/README.md
1
# requirejs-bower
2

  
3
Bower packaging for [RequireJS](http://requirejs.org).
4

  
src/sunstone/public/bower_components/requirejs/bower.json
1
{
2
  "name": "requirejs",
3
  "version": "2.1.17",
4
  "homepage": "http://requirejs.org",
5
  "authors": [
6
    "jrburke.com"
7
  ],
8
  "description": "A file and module loader for JavaScript",
9
  "main": "require.js",
10
  "keywords": [
11
    "AMD"
12
  ],
13
  "license": "new BSD, and MIT"
14
}
src/sunstone/public/bower_components/requirejs/require.js
1
/** vim: et:ts=4:sw=4:sts=4
2
 * @license RequireJS 2.1.17 Copyright (c) 2010-2015, The Dojo Foundation All Rights Reserved.
3
 * Available via the MIT or new BSD license.
4
 * see: http://github.com/jrburke/requirejs for details
5
 */
6
//Not using strict: uneven strict support in browsers, #392, and causes
7
//problems with requirejs.exec()/transpiler plugins that may not be strict.
8
/*jslint regexp: true, nomen: true, sloppy: true */
9
/*global window, navigator, document, importScripts, setTimeout, opera */
10

  
11
var requirejs, require, define;
12
(function (global) {
13
    var req, s, head, baseElement, dataMain, src,
14
        interactiveScript, currentlyAddingScript, mainScript, subPath,
15
        version = '2.1.17',
16
        commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
17
        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
18
        jsSuffixRegExp = /\.js$/,
19
        currDirRegExp = /^\.\//,
20
        op = Object.prototype,
21
        ostring = op.toString,
22
        hasOwn = op.hasOwnProperty,
23
        ap = Array.prototype,
24
        apsp = ap.splice,
25
        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
26
        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
27
        //PS3 indicates loaded and complete, but need to wait for complete
28
        //specifically. Sequence is 'loading', 'loaded', execution,
29
        // then 'complete'. The UA check is unfortunate, but not sure how
30
        //to feature test w/o causing perf issues.
31
        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
32
                      /^complete$/ : /^(complete|loaded)$/,
33
        defContextName = '_',
34
        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
35
        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
36
        contexts = {},
37
        cfg = {},
38
        globalDefQueue = [],
39
        useInteractive = false;
40

  
41
    function isFunction(it) {
42
        return ostring.call(it) === '[object Function]';
43
    }
44

  
45
    function isArray(it) {
46
        return ostring.call(it) === '[object Array]';
47
    }
48

  
49
    /**
50
     * Helper function for iterating over an array. If the func returns
51
     * a true value, it will break out of the loop.
52
     */
53
    function each(ary, func) {
54
        if (ary) {
55
            var i;
56
            for (i = 0; i < ary.length; i += 1) {
57
                if (ary[i] && func(ary[i], i, ary)) {
58
                    break;
59
                }
60
            }
61
        }
62
    }
63

  
64
    /**
65
     * Helper function for iterating over an array backwards. If the func
66
     * returns a true value, it will break out of the loop.
67
     */
68
    function eachReverse(ary, func) {
69
        if (ary) {
70
            var i;
71
            for (i = ary.length - 1; i > -1; i -= 1) {
72
                if (ary[i] && func(ary[i], i, ary)) {
73
                    break;
74
                }
75
            }
76
        }
77
    }
78

  
79
    function hasProp(obj, prop) {
80
        return hasOwn.call(obj, prop);
81
    }
82

  
83
    function getOwn(obj, prop) {
84
        return hasProp(obj, prop) && obj[prop];
85
    }
86

  
87
    /**
88
     * Cycles over properties in an object and calls a function for each
89
     * property value. If the function returns a truthy value, then the
90
     * iteration is stopped.
91
     */
92
    function eachProp(obj, func) {
93
        var prop;
94
        for (prop in obj) {
95
            if (hasProp(obj, prop)) {
96
                if (func(obj[prop], prop)) {
97
                    break;
98
                }
99
            }
100
        }
101
    }
102

  
103
    /**
104
     * Simple function to mix in properties from source into target,
105
     * but only if target does not already have a property of the same name.
106
     */
107
    function mixin(target, source, force, deepStringMixin) {
108
        if (source) {
109
            eachProp(source, function (value, prop) {
110
                if (force || !hasProp(target, prop)) {
111
                    if (deepStringMixin && typeof value === 'object' && value &&
112
                        !isArray(value) && !isFunction(value) &&
113
                        !(value instanceof RegExp)) {
114

  
115
                        if (!target[prop]) {
116
                            target[prop] = {};
117
                        }
118
                        mixin(target[prop], value, force, deepStringMixin);
119
                    } else {
120
                        target[prop] = value;
121
                    }
122
                }
123
            });
124
        }
125
        return target;
126
    }
127

  
128
    //Similar to Function.prototype.bind, but the 'this' object is specified
129
    //first, since it is easier to read/figure out what 'this' will be.
130
    function bind(obj, fn) {
131
        return function () {
132
            return fn.apply(obj, arguments);
133
        };
134
    }
135

  
136
    function scripts() {
137
        return document.getElementsByTagName('script');
138
    }
139

  
140
    function defaultOnError(err) {
141
        throw err;
142
    }
143

  
144
    //Allow getting a global that is expressed in
145
    //dot notation, like 'a.b.c'.
146
    function getGlobal(value) {
147
        if (!value) {
148
            return value;
149
        }
150
        var g = global;
151
        each(value.split('.'), function (part) {
152
            g = g[part];
153
        });
154
        return g;
155
    }
156

  
157
    /**
158
     * Constructs an error with a pointer to an URL with more information.
159
     * @param {String} id the error ID that maps to an ID on a web page.
160
     * @param {String} message human readable error.
161
     * @param {Error} [err] the original error, if there is one.
162
     *
163
     * @returns {Error}
164
     */
165
    function makeError(id, msg, err, requireModules) {
166
        var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
167
        e.requireType = id;
168
        e.requireModules = requireModules;
169
        if (err) {
170
            e.originalError = err;
171
        }
172
        return e;
173
    }
174

  
175
    if (typeof define !== 'undefined') {
176
        //If a define is already in play via another AMD loader,
177
        //do not overwrite.
178
        return;
179
    }
180

  
181
    if (typeof requirejs !== 'undefined') {
182
        if (isFunction(requirejs)) {
183
            //Do not overwrite an existing requirejs instance.
184
            return;
185
        }
186
        cfg = requirejs;
187
        requirejs = undefined;
188
    }
189

  
190
    //Allow for a require config object
191
    if (typeof require !== 'undefined' && !isFunction(require)) {
192
        //assume it is a config object.
193
        cfg = require;
194
        require = undefined;
195
    }
196

  
197
    function newContext(contextName) {
198
        var inCheckLoaded, Module, context, handlers,
199
            checkLoadedTimeoutId,
200
            config = {
201
                //Defaults. Do not set a default for map
202
                //config to speed up normalize(), which
203
                //will run faster if there is no default.
204
                waitSeconds: 7,
205
                baseUrl: './',
206
                paths: {},
207
                bundles: {},
208
                pkgs: {},
209
                shim: {},
210
                config: {}
211
            },
212
            registry = {},
213
            //registry of just enabled modules, to speed
214
            //cycle breaking code when lots of modules
215
            //are registered, but not activated.
216
            enabledRegistry = {},
217
            undefEvents = {},
218
            defQueue = [],
219
            defined = {},
220
            urlFetched = {},
221
            bundlesMap = {},
222
            requireCounter = 1,
223
            unnormalizedCounter = 1;
224

  
225
        /**
226
         * Trims the . and .. from an array of path segments.
227
         * It will keep a leading path segment if a .. will become
228
         * the first path segment, to help with module name lookups,
229
         * which act like paths, but can be remapped. But the end result,
230
         * all paths that use this function should look normalized.
231
         * NOTE: this method MODIFIES the input array.
232
         * @param {Array} ary the array of path segments.
233
         */
234
        function trimDots(ary) {
235
            var i, part;
236
            for (i = 0; i < ary.length; i++) {
237
                part = ary[i];
238
                if (part === '.') {
239
                    ary.splice(i, 1);
240
                    i -= 1;
241
                } else if (part === '..') {
242
                    // If at the start, or previous value is still ..,
243
                    // keep them so that when converted to a path it may
244
                    // still work when converted to a path, even though
245
                    // as an ID it is less than ideal. In larger point
246
                    // releases, may be better to just kick out an error.
247
                    if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
248
                        continue;
249
                    } else if (i > 0) {
250
                        ary.splice(i - 1, 2);
251
                        i -= 2;
252
                    }
253
                }
254
            }
255
        }
256

  
257
        /**
258
         * Given a relative module name, like ./something, normalize it to
259
         * a real name that can be mapped to a path.
260
         * @param {String} name the relative name
261
         * @param {String} baseName a real name that the name arg is relative
262
         * to.
263
         * @param {Boolean} applyMap apply the map config to the value. Should
264
         * only be done if this normalization is for a dependency ID.
265
         * @returns {String} normalized name
266
         */
267
        function normalize(name, baseName, applyMap) {
268
            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
269
                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
270
                baseParts = (baseName && baseName.split('/')),
271
                map = config.map,
272
                starMap = map && map['*'];
273

  
274
            //Adjust any relative paths.
275
            if (name) {
276
                name = name.split('/');
277
                lastIndex = name.length - 1;
278

  
279
                // If wanting node ID compatibility, strip .js from end
280
                // of IDs. Have to do this here, and not in nameToUrl
281
                // because node allows either .js or non .js to map
282
                // to same file.
283
                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
284
                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
285
                }
286

  
287
                // Starts with a '.' so need the baseName
288
                if (name[0].charAt(0) === '.' && baseParts) {
289
                    //Convert baseName to array, and lop off the last part,
290
                    //so that . matches that 'directory' and not name of the baseName's
291
                    //module. For instance, baseName of 'one/two/three', maps to
292
                    //'one/two/three.js', but we want the directory, 'one/two' for
293
                    //this normalization.
294
                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
295
                    name = normalizedBaseParts.concat(name);
296
                }
297

  
298
                trimDots(name);
299
                name = name.join('/');
300
            }
301

  
302
            //Apply map config if available.
303
            if (applyMap && map && (baseParts || starMap)) {
304
                nameParts = name.split('/');
305

  
306
                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
307
                    nameSegment = nameParts.slice(0, i).join('/');
308

  
309
                    if (baseParts) {
310
                        //Find the longest baseName segment match in the config.
311
                        //So, do joins on the biggest to smallest lengths of baseParts.
312
                        for (j = baseParts.length; j > 0; j -= 1) {
313
                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
314

  
315
                            //baseName segment has config, find if it has one for
316
                            //this name.
317
                            if (mapValue) {
318
                                mapValue = getOwn(mapValue, nameSegment);
319
                                if (mapValue) {
320
                                    //Match, update name to the new value.
321
                                    foundMap = mapValue;
322
                                    foundI = i;
323
                                    break outerLoop;
324
                                }
325
                            }
326
                        }
327
                    }
328

  
329
                    //Check for a star map match, but just hold on to it,
330
                    //if there is a shorter segment match later in a matching
331
                    //config, then favor over this star map.
332
                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
333
                        foundStarMap = getOwn(starMap, nameSegment);
334
                        starI = i;
335
                    }
336
                }
337

  
338
                if (!foundMap && foundStarMap) {
339
                    foundMap = foundStarMap;
340
                    foundI = starI;
341
                }
342

  
343
                if (foundMap) {
344
                    nameParts.splice(0, foundI, foundMap);
345
                    name = nameParts.join('/');
346
                }
347
            }
348

  
349
            // If the name points to a package's name, use
350
            // the package main instead.
351
            pkgMain = getOwn(config.pkgs, name);
352

  
353
            return pkgMain ? pkgMain : name;
354
        }
355

  
356
        function removeScript(name) {
357
            if (isBrowser) {
358
                each(scripts(), function (scriptNode) {
359
                    if (scriptNode.getAttribute('data-requiremodule') === name &&
360
                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
361
                        scriptNode.parentNode.removeChild(scriptNode);
362
                        return true;
363
                    }
364
                });
365
            }
366
        }
367

  
368
        function hasPathFallback(id) {
369
            var pathConfig = getOwn(config.paths, id);
370
            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
371
                //Pop off the first array value, since it failed, and
372
                //retry
373
                pathConfig.shift();
374
                context.require.undef(id);
375

  
376
                //Custom require that does not do map translation, since
377
                //ID is "absolute", already mapped/resolved.
378
                context.makeRequire(null, {
379
                    skipMap: true
380
                })([id]);
381

  
382
                return true;
383
            }
384
        }
385

  
386
        //Turns a plugin!resource to [plugin, resource]
387
        //with the plugin being undefined if the name
388
        //did not have a plugin prefix.
389
        function splitPrefix(name) {
390
            var prefix,
391
                index = name ? name.indexOf('!') : -1;
392
            if (index > -1) {
393
                prefix = name.substring(0, index);
394
                name = name.substring(index + 1, name.length);
395
            }
396
            return [prefix, name];
397
        }
398

  
399
        /**
400
         * Creates a module mapping that includes plugin prefix, module
401
         * name, and path. If parentModuleMap is provided it will
402
         * also normalize the name via require.normalize()
403
         *
404
         * @param {String} name the module name
405
         * @param {String} [parentModuleMap] parent module map
406
         * for the module name, used to resolve relative names.
407
         * @param {Boolean} isNormalized: is the ID already normalized.
408
         * This is true if this call is done for a define() module ID.
409
         * @param {Boolean} applyMap: apply the map config to the ID.
410
         * Should only be true if this map is for a dependency.
411
         *
412
         * @returns {Object}
413
         */
414
        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
415
            var url, pluginModule, suffix, nameParts,
416
                prefix = null,
417
                parentName = parentModuleMap ? parentModuleMap.name : null,
418
                originalName = name,
419
                isDefine = true,
420
                normalizedName = '';
421

  
422
            //If no name, then it means it is a require call, generate an
423
            //internal name.
424
            if (!name) {
425
                isDefine = false;
426
                name = '_@r' + (requireCounter += 1);
427
            }
428

  
429
            nameParts = splitPrefix(name);
430
            prefix = nameParts[0];
431
            name = nameParts[1];
432

  
433
            if (prefix) {
434
                prefix = normalize(prefix, parentName, applyMap);
435
                pluginModule = getOwn(defined, prefix);
436
            }
437

  
438
            //Account for relative paths if there is a base name.
439
            if (name) {
440
                if (prefix) {
441
                    if (pluginModule && pluginModule.normalize) {
442
                        //Plugin is loaded, use its normalize method.
443
                        normalizedName = pluginModule.normalize(name, function (name) {
444
                            return normalize(name, parentName, applyMap);
445
                        });
446
                    } else {
447
                        // If nested plugin references, then do not try to
448
                        // normalize, as it will not normalize correctly. This
449
                        // places a restriction on resourceIds, and the longer
450
                        // term solution is not to normalize until plugins are
451
                        // loaded and all normalizations to allow for async
452
                        // loading of a loader plugin. But for now, fixes the
453
                        // common uses. Details in #1131
454
                        normalizedName = name.indexOf('!') === -1 ?
455
                                         normalize(name, parentName, applyMap) :
456
                                         name;
457
                    }
458
                } else {
459
                    //A regular module.
460
                    normalizedName = normalize(name, parentName, applyMap);
461

  
462
                    //Normalized name may be a plugin ID due to map config
463
                    //application in normalize. The map config values must
464
                    //already be normalized, so do not need to redo that part.
465
                    nameParts = splitPrefix(normalizedName);
466
                    prefix = nameParts[0];
467
                    normalizedName = nameParts[1];
468
                    isNormalized = true;
469

  
470
                    url = context.nameToUrl(normalizedName);
471
                }
472
            }
473

  
474
            //If the id is a plugin id that cannot be determined if it needs
475
            //normalization, stamp it with a unique ID so two matching relative
476
            //ids that may conflict can be separate.
477
            suffix = prefix && !pluginModule && !isNormalized ?
478
                     '_unnormalized' + (unnormalizedCounter += 1) :
479
                     '';
480

  
481
            return {
482
                prefix: prefix,
483
                name: normalizedName,
484
                parentMap: parentModuleMap,
485
                unnormalized: !!suffix,
486
                url: url,
487
                originalName: originalName,
488
                isDefine: isDefine,
489
                id: (prefix ?
490
                        prefix + '!' + normalizedName :
491
                        normalizedName) + suffix
492
            };
493
        }
494

  
495
        function getModule(depMap) {
496
            var id = depMap.id,
497
                mod = getOwn(registry, id);
498

  
499
            if (!mod) {
500
                mod = registry[id] = new context.Module(depMap);
501
            }
502

  
503
            return mod;
504
        }
505

  
506
        function on(depMap, name, fn) {
507
            var id = depMap.id,
508
                mod = getOwn(registry, id);
509

  
510
            if (hasProp(defined, id) &&
511
                    (!mod || mod.defineEmitComplete)) {
512
                if (name === 'defined') {
513
                    fn(defined[id]);
514
                }
515
            } else {
516
                mod = getModule(depMap);
517
                if (mod.error && name === 'error') {
518
                    fn(mod.error);
519
                } else {
520
                    mod.on(name, fn);
521
                }
522
            }
523
        }
524

  
525
        function onError(err, errback) {
526
            var ids = err.requireModules,
527
                notified = false;
528

  
529
            if (errback) {
530
                errback(err);
531
            } else {
532
                each(ids, function (id) {
533
                    var mod = getOwn(registry, id);
534
                    if (mod) {
535
                        //Set error on module, so it skips timeout checks.
536
                        mod.error = err;
537
                        if (mod.events.error) {
538
                            notified = true;
539
                            mod.emit('error', err);
540
                        }
541
                    }
542
                });
543

  
544
                if (!notified) {
545
                    req.onError(err);
546
                }
547
            }
548
        }
549

  
550
        /**
551
         * Internal method to transfer globalQueue items to this context's
552
         * defQueue.
553
         */
554
        function takeGlobalQueue() {
555
            //Push all the globalDefQueue items into the context's defQueue
556
            if (globalDefQueue.length) {
557
                //Array splice in the values since the context code has a
558
                //local var ref to defQueue, so cannot just reassign the one
559
                //on context.
560
                apsp.apply(defQueue,
561
                           [defQueue.length, 0].concat(globalDefQueue));
562
                globalDefQueue = [];
563
            }
564
        }
565

  
566
        handlers = {
567
            'require': function (mod) {
568
                if (mod.require) {
569
                    return mod.require;
570
                } else {
571
                    return (mod.require = context.makeRequire(mod.map));
572
                }
573
            },
574
            'exports': function (mod) {
575
                mod.usingExports = true;
576
                if (mod.map.isDefine) {
577
                    if (mod.exports) {
578
                        return (defined[mod.map.id] = mod.exports);
579
                    } else {
580
                        return (mod.exports = defined[mod.map.id] = {});
581
                    }
582
                }
583
            },
584
            'module': function (mod) {
585
                if (mod.module) {
586
                    return mod.module;
587
                } else {
588
                    return (mod.module = {
589
                        id: mod.map.id,
590
                        uri: mod.map.url,
591
                        config: function () {
592
                            return  getOwn(config.config, mod.map.id) || {};
593
                        },
594
                        exports: mod.exports || (mod.exports = {})
595
                    });
596
                }
597
            }
598
        };
599

  
600
        function cleanRegistry(id) {
601
            //Clean up machinery used for waiting modules.
602
            delete registry[id];
603
            delete enabledRegistry[id];
604
        }
605

  
606
        function breakCycle(mod, traced, processed) {
607
            var id = mod.map.id;
608

  
609
            if (mod.error) {
610
                mod.emit('error', mod.error);
611
            } else {
612
                traced[id] = true;
613
                each(mod.depMaps, function (depMap, i) {
614
                    var depId = depMap.id,
615
                        dep = getOwn(registry, depId);
616

  
617
                    //Only force things that have not completed
618
                    //being defined, so still in the registry,
619
                    //and only if it has not been matched up
620
                    //in the module already.
621
                    if (dep && !mod.depMatched[i] && !processed[depId]) {
622
                        if (getOwn(traced, depId)) {
623
                            mod.defineDep(i, defined[depId]);
624
                            mod.check(); //pass false?
625
                        } else {
626
                            breakCycle(dep, traced, processed);
627
                        }
628
                    }
629
                });
630
                processed[id] = true;
631
            }
632
        }
633

  
634
        function checkLoaded() {
635
            var err, usingPathFallback,
636
                waitInterval = config.waitSeconds * 1000,
637
                //It is possible to disable the wait interval by using waitSeconds of 0.
638
                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
639
                noLoads = [],
640
                reqCalls = [],
641
                stillLoading = false,
642
                needCycleCheck = true;
643

  
644
            //Do not bother if this call was a result of a cycle break.
645
            if (inCheckLoaded) {
646
                return;
647
            }
648

  
649
            inCheckLoaded = true;
650

  
651
            //Figure out the state of all the modules.
652
            eachProp(enabledRegistry, function (mod) {
653
                var map = mod.map,
654
                    modId = map.id;
655

  
656
                //Skip things that are not enabled or in error state.
657
                if (!mod.enabled) {
658
                    return;
659
                }
660

  
661
                if (!map.isDefine) {
662
                    reqCalls.push(mod);
663
                }
664

  
665
                if (!mod.error) {
666
                    //If the module should be executed, and it has not
667
                    //been inited and time is up, remember it.
668
                    if (!mod.inited && expired) {
669
                        if (hasPathFallback(modId)) {
670
                            usingPathFallback = true;
671
                            stillLoading = true;
672
                        } else {
673
                            noLoads.push(modId);
674
                            removeScript(modId);
675
                        }
676
                    } else if (!mod.inited && mod.fetched && map.isDefine) {
677
                        stillLoading = true;
678
                        if (!map.prefix) {
679
                            //No reason to keep looking for unfinished
680
                            //loading. If the only stillLoading is a
681
                            //plugin resource though, keep going,
682
                            //because it may be that a plugin resource
683
                            //is waiting on a non-plugin cycle.
684
                            return (needCycleCheck = false);
685
                        }
686
                    }
687
                }
688
            });
689

  
690
            if (expired && noLoads.length) {
691
                //If wait time expired, throw error of unloaded modules.
692
                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
693
                err.contextName = context.contextName;
694
                return onError(err);
695
            }
696

  
697
            //Not expired, check for a cycle.
698
            if (needCycleCheck) {
699
                each(reqCalls, function (mod) {
700
                    breakCycle(mod, {}, {});
701
                });
702
            }
703

  
704
            //If still waiting on loads, and the waiting load is something
705
            //other than a plugin resource, or there are still outstanding
706
            //scripts, then just try back later.
707
            if ((!expired || usingPathFallback) && stillLoading) {
708
                //Something is still waiting to load. Wait for it, but only
709
                //if a timeout is not already in effect.
710
                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
711
                    checkLoadedTimeoutId = setTimeout(function () {
712
                        checkLoadedTimeoutId = 0;
713
                        checkLoaded();
714
                    }, 50);
715
                }
716
            }
717

  
718
            inCheckLoaded = false;
719
        }
720

  
721
        Module = function (map) {
722
            this.events = getOwn(undefEvents, map.id) || {};
723
            this.map = map;
724
            this.shim = getOwn(config.shim, map.id);
725
            this.depExports = [];
726
            this.depMaps = [];
727
            this.depMatched = [];
728
            this.pluginMaps = {};
729
            this.depCount = 0;
730

  
731
            /* this.exports this.factory
732
               this.depMaps = [],
733
               this.enabled, this.fetched
734
            */
735
        };
736

  
737
        Module.prototype = {
738
            init: function (depMaps, factory, errback, options) {
739
                options = options || {};
740

  
741
                //Do not do more inits if already done. Can happen if there
742
                //are multiple define calls for the same module. That is not
743
                //a normal, common case, but it is also not unexpected.
744
                if (this.inited) {
745
                    return;
746
                }
747

  
748
                this.factory = factory;
749

  
750
                if (errback) {
751
                    //Register for errors on this module.
752
                    this.on('error', errback);
753
                } else if (this.events.error) {
754
                    //If no errback already, but there are error listeners
755
                    //on this module, set up an errback to pass to the deps.
756
                    errback = bind(this, function (err) {
757
                        this.emit('error', err);
758
                    });
759
                }
760

  
761
                //Do a copy of the dependency array, so that
762
                //source inputs are not modified. For example
763
                //"shim" deps are passed in here directly, and
764
                //doing a direct modification of the depMaps array
765
                //would affect that config.
766
                this.depMaps = depMaps && depMaps.slice(0);
767

  
768
                this.errback = errback;
769

  
770
                //Indicate this module has be initialized
771
                this.inited = true;
772

  
773
                this.ignore = options.ignore;
774

  
775
                //Could have option to init this module in enabled mode,
776
                //or could have been previously marked as enabled. However,
777
                //the dependencies are not known until init is called. So
778
                //if enabled previously, now trigger dependencies as enabled.
779
                if (options.enabled || this.enabled) {
780
                    //Enable this module and dependencies.
781
                    //Will call this.check()
782
                    this.enable();
783
                } else {
784
                    this.check();
785
                }
786
            },
787

  
788
            defineDep: function (i, depExports) {
789
                //Because of cycles, defined callback for a given
790
                //export can be called more than once.
791
                if (!this.depMatched[i]) {
792
                    this.depMatched[i] = true;
793
                    this.depCount -= 1;
794
                    this.depExports[i] = depExports;
795
                }
796
            },
797

  
798
            fetch: function () {
799
                if (this.fetched) {
800
                    return;
801
                }
802
                this.fetched = true;
803

  
804
                context.startTime = (new Date()).getTime();
805

  
806
                var map = this.map;
807

  
808
                //If the manager is for a plugin managed resource,
809
                //ask the plugin to load it now.
810
                if (this.shim) {
811
                    context.makeRequire(this.map, {
812
                        enableBuildCallback: true
813
                    })(this.shim.deps || [], bind(this, function () {
814
                        return map.prefix ? this.callPlugin() : this.load();
815
                    }));
816
                } else {
817
                    //Regular dependency.
818
                    return map.prefix ? this.callPlugin() : this.load();
819
                }
820
            },
821

  
822
            load: function () {
823
                var url = this.map.url;
824

  
825
                //Regular dependency.
826
                if (!urlFetched[url]) {
827
                    urlFetched[url] = true;
828
                    context.load(this.map.id, url);
829
                }
830
            },
831

  
832
            /**
833
             * Checks if the module is ready to define itself, and if so,
834
             * define it.
835
             */
836
            check: function () {
837
                if (!this.enabled || this.enabling) {
838
                    return;
839
                }
840

  
841
                var err, cjsModule,
842
                    id = this.map.id,
843
                    depExports = this.depExports,
844
                    exports = this.exports,
845
                    factory = this.factory;
846

  
847
                if (!this.inited) {
848
                    this.fetch();
849
                } else if (this.error) {
850
                    this.emit('error', this.error);
851
                } else if (!this.defining) {
852
                    //The factory could trigger another require call
853
                    //that would result in checking this module to
854
                    //define itself again. If already in the process
855
                    //of doing that, skip this work.
856
                    this.defining = true;
857

  
858
                    if (this.depCount < 1 && !this.defined) {
859
                        if (isFunction(factory)) {
860
                            //If there is an error listener, favor passing
861
                            //to that instead of throwing an error. However,
862
                            //only do it for define()'d  modules. require
863
                            //errbacks should not be called for failures in
864
                            //their callbacks (#699). However if a global
865
                            //onError is set, use that.
866
                            if ((this.events.error && this.map.isDefine) ||
867
                                req.onError !== defaultOnError) {
868
                                try {
869
                                    exports = context.execCb(id, factory, depExports, exports);
870
                                } catch (e) {
871
                                    err = e;
872
                                }
873
                            } else {
874
                                exports = context.execCb(id, factory, depExports, exports);
875
                            }
876

  
877
                            // Favor return value over exports. If node/cjs in play,
878
                            // then will not have a return value anyway. Favor
879
                            // module.exports assignment over exports object.
880
                            if (this.map.isDefine && exports === undefined) {
881
                                cjsModule = this.module;
882
                                if (cjsModule) {
883
                                    exports = cjsModule.exports;
884
                                } else if (this.usingExports) {
885
                                    //exports already set the defined value.
886
                                    exports = this.exports;
887
                                }
888
                            }
889

  
890
                            if (err) {
891
                                err.requireMap = this.map;
892
                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
893
                                err.requireType = this.map.isDefine ? 'define' : 'require';
894
                                return onError((this.error = err));
895
                            }
896

  
897
                        } else {
898
                            //Just a literal value
899
                            exports = factory;
900
                        }
901

  
902
                        this.exports = exports;
903

  
904
                        if (this.map.isDefine && !this.ignore) {
905
                            defined[id] = exports;
906

  
907
                            if (req.onResourceLoad) {
908
                                req.onResourceLoad(context, this.map, this.depMaps);
909
                            }
910
                        }
911

  
912
                        //Clean up
913
                        cleanRegistry(id);
914

  
915
                        this.defined = true;
916
                    }
917

  
918
                    //Finished the define stage. Allow calling check again
919
                    //to allow define notifications below in the case of a
920
                    //cycle.
921
                    this.defining = false;
922

  
923
                    if (this.defined && !this.defineEmitted) {
924
                        this.defineEmitted = true;
925
                        this.emit('defined', this.exports);
926
                        this.defineEmitComplete = true;
927
                    }
928

  
929
                }
930
            },
931

  
932
            callPlugin: function () {
933
                var map = this.map,
934
                    id = map.id,
935
                    //Map already normalized the prefix.
936
                    pluginMap = makeModuleMap(map.prefix);
937

  
938
                //Mark this as a dependency for this plugin, so it
939
                //can be traced for cycles.
940
                this.depMaps.push(pluginMap);
941

  
942
                on(pluginMap, 'defined', bind(this, function (plugin) {
943
                    var load, normalizedMap, normalizedMod,
944
                        bundleId = getOwn(bundlesMap, this.map.id),
945
                        name = this.map.name,
946
                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
947
                        localRequire = context.makeRequire(map.parentMap, {
948
                            enableBuildCallback: true
949
                        });
950

  
951
                    //If current map is not normalized, wait for that
952
                    //normalized name to load instead of continuing.
953
                    if (this.map.unnormalized) {
954
                        //Normalize the ID if the plugin allows it.
955
                        if (plugin.normalize) {
956
                            name = plugin.normalize(name, function (name) {
957
                                return normalize(name, parentName, true);
958
                            }) || '';
959
                        }
960

  
961
                        //prefix and name should already be normalized, no need
962
                        //for applying map config again either.
963
                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
964
                                                      this.map.parentMap);
965
                        on(normalizedMap,
966
                            'defined', bind(this, function (value) {
967
                                this.init([], function () { return value; }, null, {
968
                                    enabled: true,
969
                                    ignore: true
970
                                });
971
                            }));
972

  
973
                        normalizedMod = getOwn(registry, normalizedMap.id);
974
                        if (normalizedMod) {
975
                            //Mark this as a dependency for this plugin, so it
976
                            //can be traced for cycles.
977
                            this.depMaps.push(normalizedMap);
978

  
979
                            if (this.events.error) {
980
                                normalizedMod.on('error', bind(this, function (err) {
981
                                    this.emit('error', err);
982
                                }));
983
                            }
984
                            normalizedMod.enable();
985
                        }
986

  
987
                        return;
988
                    }
989

  
990
                    //If a paths config, then just load that file instead to
991
                    //resolve the plugin, as it is built into that paths layer.
992
                    if (bundleId) {
993
                        this.map.url = context.nameToUrl(bundleId);
994
                        this.load();
995
                        return;
996
                    }
997

  
998
                    load = bind(this, function (value) {
999
                        this.init([], function () { return value; }, null, {
1000
                            enabled: true
1001
                        });
1002
                    });
1003

  
1004
                    load.error = bind(this, function (err) {
1005
                        this.inited = true;
1006
                        this.error = err;
1007
                        err.requireModules = [id];
1008

  
1009
                        //Remove temp unnormalized modules for this module,
1010
                        //since they will never be resolved otherwise now.
1011
                        eachProp(registry, function (mod) {
1012
                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
1013
                                cleanRegistry(mod.map.id);
1014
                            }
1015
                        });
1016

  
1017
                        onError(err);
1018
                    });
1019

  
1020
                    //Allow plugins to load other code without having to know the
1021
                    //context or how to 'complete' the load.
1022
                    load.fromText = bind(this, function (text, textAlt) {
1023
                        /*jslint evil: true */
1024
                        var moduleName = map.name,
1025
                            moduleMap = makeModuleMap(moduleName),
1026
                            hasInteractive = useInteractive;
1027

  
1028
                        //As of 2.1.0, support just passing the text, to reinforce
1029
                        //fromText only being called once per resource. Still
1030
                        //support old style of passing moduleName but discard
1031
                        //that moduleName in favor of the internal ref.
1032
                        if (textAlt) {
1033
                            text = textAlt;
1034
                        }
1035

  
1036
                        //Turn off interactive script matching for IE for any define
1037
                        //calls in the text, then turn it back on at the end.
1038
                        if (hasInteractive) {
1039
                            useInteractive = false;
1040
                        }
1041

  
1042
                        //Prime the system by creating a module instance for
1043
                        //it.
1044
                        getModule(moduleMap);
1045

  
1046
                        //Transfer any config to this other module.
1047
                        if (hasProp(config.config, id)) {
1048
                            config.config[moduleName] = config.config[id];
1049
                        }
1050

  
1051
                        try {
1052
                            req.exec(text);
1053
                        } catch (e) {
1054
                            return onError(makeError('fromtexteval',
1055
                                             'fromText eval for ' + id +
1056
                                            ' failed: ' + e,
1057
                                             e,
1058
                                             [id]));
1059
                        }
1060

  
1061
                        if (hasInteractive) {
1062
                            useInteractive = true;
1063
                        }
1064

  
1065
                        //Mark this as a dependency for the plugin
1066
                        //resource
1067
                        this.depMaps.push(moduleMap);
1068

  
1069
                        //Support anonymous modules.
1070
                        context.completeLoad(moduleName);
1071

  
1072
                        //Bind the value of that module to the value for this
1073
                        //resource ID.
1074
                        localRequire([moduleName], load);
1075
                    });
1076

  
1077
                    //Use parentName here since the plugin's name is not reliable,
1078
                    //could be some weird string with no path that actually wants to
1079
                    //reference the parentName's path.
1080
                    plugin.load(map.name, localRequire, load, config);
1081
                }));
1082

  
1083
                context.enable(pluginMap, this);
1084
                this.pluginMaps[pluginMap.id] = pluginMap;
1085
            },
1086

  
1087
            enable: function () {
1088
                enabledRegistry[this.map.id] = this;
1089
                this.enabled = true;
1090

  
1091
                //Set flag mentioning that the module is enabling,
1092
                //so that immediate calls to the defined callbacks
1093
                //for dependencies do not trigger inadvertent load
1094
                //with the depCount still being zero.
1095
                this.enabling = true;
1096

  
1097
                //Enable each dependency
1098
                each(this.depMaps, bind(this, function (depMap, i) {
1099
                    var id, mod, handler;
1100

  
1101
                    if (typeof depMap === 'string') {
1102
                        //Dependency needs to be converted to a depMap
1103
                        //and wired up to this module.
1104
                        depMap = makeModuleMap(depMap,
1105
                                               (this.map.isDefine ? this.map : this.map.parentMap),
1106
                                               false,
1107
                                               !this.skipMap);
1108
                        this.depMaps[i] = depMap;
1109

  
1110
                        handler = getOwn(handlers, depMap.id);
1111

  
1112
                        if (handler) {
1113
                            this.depExports[i] = handler(this);
1114
                            return;
1115
                        }
1116

  
1117
                        this.depCount += 1;
1118

  
1119
                        on(depMap, 'defined', bind(this, function (depExports) {
1120
                            this.defineDep(i, depExports);
1121
                            this.check();
1122
                        }));
1123

  
1124
                        if (this.errback) {
1125
                            on(depMap, 'error', bind(this, this.errback));
1126
                        } else if (this.events.error) {
1127
                            // No direct errback on this module, but something
1128
                            // else is listening for errors, so be sure to
1129
                            // propagate the error correctly.
1130
                            on(depMap, 'error', bind(this, function(err) {
1131
                                this.emit('error', err);
1132
                            }));
1133
                        }
1134
                    }
1135

  
1136
                    id = depMap.id;
1137
                    mod = registry[id];
1138

  
1139
                    //Skip special modules like 'require', 'exports', 'module'
1140
                    //Also, don't call enable if it is already enabled,
1141
                    //important in circular dependency cases.
1142
                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
1143
                        context.enable(depMap, this);
1144
                    }
1145
                }));
1146

  
1147
                //Enable each plugin that is used in
1148
                //a dependency
1149
                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
1150
                    var mod = getOwn(registry, pluginMap.id);
1151
                    if (mod && !mod.enabled) {
1152
                        context.enable(pluginMap, this);
1153
                    }
1154
                }));
1155

  
1156
                this.enabling = false;
1157

  
1158
                this.check();
1159
            },
1160

  
1161
            on: function (name, cb) {
1162
                var cbs = this.events[name];
1163
                if (!cbs) {
1164
                    cbs = this.events[name] = [];
1165
                }
1166
                cbs.push(cb);
1167
            },
1168

  
1169
            emit: function (name, evt) {
1170
                each(this.events[name], function (cb) {
1171
                    cb(evt);
1172
                });
1173
                if (name === 'error') {
1174
                    //Now that the error handler was triggered, remove
1175
                    //the listeners, since this broken Module instance
1176
                    //can stay around for a while in the registry.
1177
                    delete this.events[name];
1178
                }
1179
            }
1180
        };
1181

  
1182
        function callGetModule(args) {
1183
            //Skip modules already defined.
1184
            if (!hasProp(defined, args[0])) {
1185
                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
1186
            }
1187
        }
1188

  
1189
        function removeListener(node, func, name, ieName) {
1190
            //Favor detachEvent because of IE9
1191
            //issue, see attachEvent/addEventListener comment elsewhere
1192
            //in this file.
1193
            if (node.detachEvent && !isOpera) {
1194
                //Probably IE. If not it will throw an error, which will be
1195
                //useful to know.
1196
                if (ieName) {
1197
                    node.detachEvent(ieName, func);
1198
                }
1199
            } else {
1200
                node.removeEventListener(name, func, false);
1201
            }
1202
        }
1203

  
1204
        /**
1205
         * Given an event from a script node, get the requirejs info from it,
1206
         * and then removes the event listeners on the node.
1207
         * @param {Event} evt
1208
         * @returns {Object}
1209
         */
1210
        function getScriptData(evt) {
1211
            //Using currentTarget instead of target for Firefox 2.0's sake. Not
1212
            //all old browsers will be supported, but this one was easy enough
1213
            //to support and still makes sense.
1214
            var node = evt.currentTarget || evt.srcElement;
1215

  
1216
            //Remove the listeners once here.
1217
            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
1218
            removeListener(node, context.onScriptError, 'error');
1219

  
1220
            return {
1221
                node: node,
1222
                id: node && node.getAttribute('data-requiremodule')
1223
            };
1224
        }
1225

  
1226
        function intakeDefines() {
1227
            var args;
1228

  
1229
            //Any defined modules in the global queue, intake them now.
1230
            takeGlobalQueue();
1231

  
1232
            //Make sure any remaining defQueue items get properly processed.
1233
            while (defQueue.length) {
1234
                args = defQueue.shift();
1235
                if (args[0] === null) {
1236
                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
1237
                } else {
1238
                    //args are id, deps, factory. Should be normalized by the
1239
                    //define() function.
1240
                    callGetModule(args);
1241
                }
1242
            }
1243
        }
1244

  
1245
        context = {
1246
            config: config,
1247
            contextName: contextName,
1248
            registry: registry,
1249
            defined: defined,
1250
            urlFetched: urlFetched,
1251
            defQueue: defQueue,
1252
            Module: Module,
1253
            makeModuleMap: makeModuleMap,
1254
            nextTick: req.nextTick,
1255
            onError: onError,
1256

  
1257
            /**
1258
             * Set a configuration for the context.
1259
             * @param {Object} cfg config object to integrate.
1260
             */
1261
            configure: function (cfg) {
1262
                //Make sure the baseUrl ends in a slash.
1263
                if (cfg.baseUrl) {
1264
                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
1265
                        cfg.baseUrl += '/';
1266
                    }
1267
                }
1268

  
1269
                //Save off the paths since they require special processing,
1270
                //they are additive.
1271
                var shim = config.shim,
1272
                    objs = {
1273
                        paths: true,
1274
                        bundles: true,
1275
                        config: true,
1276
                        map: true
1277
                    };
1278

  
1279
                eachProp(cfg, function (value, prop) {
1280
                    if (objs[prop]) {
1281
                        if (!config[prop]) {
1282
                            config[prop] = {};
1283
                        }
1284
                        mixin(config[prop], value, true, true);
1285
                    } else {
1286
                        config[prop] = value;
1287
                    }
1288
                });
1289

  
1290
                //Reverse map the bundles
1291
                if (cfg.bundles) {
1292
                    eachProp(cfg.bundles, function (value, prop) {
1293
                        each(value, function (v) {
1294
                            if (v !== prop) {
1295
                                bundlesMap[v] = prop;
1296
                            }
1297
                        });
1298
                    });
1299
                }
1300

  
1301
                //Merge shim
1302
                if (cfg.shim) {
1303
                    eachProp(cfg.shim, function (value, id) {
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff