X-Git-Url: https://git.toastfreeware.priv.at/philipp/winterrodeln/wradmin.git/blobdiff_plain/c2d2b07d134a64271aede4886b8c1d0f6960cb4d..582150b643140e3e670d66f244812e314c7aa0c1:/wradmin/static/yui/yahoo/yahoo-debug.js diff --git a/wradmin/static/yui/yahoo/yahoo-debug.js b/wradmin/static/yui/yahoo/yahoo-debug.js new file mode 100644 index 0000000..a4bd7f3 --- /dev/null +++ b/wradmin/static/yui/yahoo/yahoo-debug.js @@ -0,0 +1,1028 @@ +/* +Copyright (c) 2009, Yahoo! Inc. All rights reserved. +Code licensed under the BSD License: +http://developer.yahoo.net/yui/license.txt +version: 2.7.0 +*/ +/** + * The YAHOO object is the single global object used by YUI Library. It + * contains utility function for setting up namespaces, inheritance, and + * logging. YAHOO.util, YAHOO.widget, and YAHOO.example are namespaces + * created automatically for and used by the library. + * @module yahoo + * @title YAHOO Global + */ + +/** + * YAHOO_config is not included as part of the library. Instead it is an + * object that can be defined by the implementer immediately before + * including the YUI library. The properties included in this object + * will be used to configure global properties needed as soon as the + * library begins to load. + * @class YAHOO_config + * @static + */ + +/** + * A reference to a function that will be executed every time a YAHOO module + * is loaded. As parameter, this function will receive the version + * information for the module. See + * YAHOO.env.getVersion for the description of the version data structure. + * @property listener + * @type Function + * @static + * @default undefined + */ + +/** + * Set to true if the library will be dynamically loaded after window.onload. + * Defaults to false + * @property injecting + * @type boolean + * @static + * @default undefined + */ + +/** + * Instructs the yuiloader component to dynamically load yui components and + * their dependencies. See the yuiloader documentation for more information + * about dynamic loading + * @property load + * @static + * @default undefined + * @see yuiloader + */ + +/** + * Forces the use of the supplied locale where applicable in the library + * @property locale + * @type string + * @static + * @default undefined + */ + +if (typeof YAHOO == "undefined" || !YAHOO) { + /** + * The YAHOO global namespace object. If YAHOO is already defined, the + * existing YAHOO object will not be overwritten so that defined + * namespaces are preserved. + * @class YAHOO + * @static + */ + var YAHOO = {}; +} + +/** + * Returns the namespace specified and creates it if it doesn't exist + * 
+ * YAHOO.namespace("property.package");
+ * YAHOO.namespace("YAHOO.property.package");
+ *
+ * Either of the above would create YAHOO.property, then + * YAHOO.property.package + * + * Be careful when naming packages. Reserved words may work in some browsers + * and not others. For instance, the following will fail in Safari: + * 
+ * YAHOO.namespace("really.long.nested.namespace");
+ *
+ * This fails because "long" is a future reserved word in ECMAScript + * + * For implementation code that uses YUI, do not create your components + * in the namespaces created by the library. defined by YUI -- create + * your own (YAHOO.util, YAHOO.widget, YAHOO.lang, YAHOO.env) + * + * @method namespace + * @static + * @param {String*} arguments 1-n namespaces to create + * @return {Object} A reference to the last namespace object created + */ +YAHOO.namespace = function() { + var a=arguments, o=null, i, j, d; + for (i=0; i + *
name:
The name of the module
+ *
version:
The version in use
+ *
build:
The build number in use
+ *
versions:
All versions that were registered
+ *
builds:
All builds that were registered.
+ *
mainClass:
An object that was was stamped with the + * current version and build. If + * mainClass.VERSION != version or mainClass.BUILD != build, + * multiple versions of pieces of the library have been + * loaded, potentially causing issues.
+ * + * + * @method getVersion + * @static + * @param {String} name the name of the module (event, slider, etc) + * @return {Object} The version info + */ +YAHOO.env.getVersion = function(name) { + return YAHOO.env.modules[name] || null; +}; + +/** + * Do not fork for a browser if it can be avoided. Use feature detection when + * you can. Use the user agent as a last resort. YAHOO.env.ua stores a version + * number for the browser engine, 0 otherwise. This value may or may not map + * to the version number of the browser using the engine. The value is + * presented as a float so that it can easily be used for boolean evaluation + * as well as for looking for a particular range of versions. Because of this, + * some of the granularity of the version info may be lost (e.g., Gecko 1.8.0.9 + * reports 1.8). + * @class YAHOO.env.ua + * @static + */ +YAHOO.env.ua = function() { + var o={ + + /** + * Internet Explorer version number or 0. Example: 6 + * @property ie + * @type float + */ + ie:0, + + /** + * Opera version number or 0. Example: 9.2 + * @property opera + * @type float + */ + opera:0, + + /** + * Gecko engine revision number. Will evaluate to 1 if Gecko + * is detected but the revision could not be found. Other browsers + * will be 0. Example: 1.8 + * 
+         * Firefox 1.0.0.4: 1.7.8   <-- Reports 1.7
+         * Firefox 1.5.0.9: 1.8.0.9 <-- Reports 1.8
+         * Firefox 2.0.0.3: 1.8.1.3 <-- Reports 1.8
+         * Firefox 3 alpha: 1.9a4   <-- Reports 1.9
+         *
+ * @property gecko + * @type float + */ + gecko:0, + + /** + * AppleWebKit version. KHTML browsers that are not WebKit browsers + * will evaluate to 1, other browsers 0. Example: 418.9.1 + * 
+         * Safari 1.3.2 (312.6): 312.8.1 <-- Reports 312.8 -- currently the 
+         *                                   latest available for Mac OSX 10.3.
+         * Safari 2.0.2:         416     <-- hasOwnProperty introduced
+         * Safari 2.0.4:         418     <-- preventDefault fixed
+         * Safari 2.0.4 (419.3): 418.9.1 <-- One version of Safari may run
+         *                                   different versions of webkit
+         * Safari 2.0.4 (419.3): 419     <-- Tiger installations that have been
+         *                                   updated, but not updated
+         *                                   to the latest patch.
+         * Webkit 212 nightly:   522+    <-- Safari 3.0 precursor (with native SVG
+         *                                   and many major issues fixed).  
+         * 3.x yahoo.com, flickr:422     <-- Safari 3.x hacks the user agent
+         *                                   string when hitting yahoo.com and 
+         *                                   flickr.com.
+         * Safari 3.0.4 (523.12):523.12  <-- First Tiger release - automatic update
+         *                                   from 2.x via the 10.4.11 OS patch
+         * Webkit nightly 1/2008:525+    <-- Supports DOMContentLoaded event.
+         *                                   yahoo.com user agent hack removed.
+         *                                   
+         *
+ * http://developer.apple.com/internet/safari/uamatrix.html + * @property webkit + * @type float + */ + webkit: 0, + + /** + * The mobile property will be set to a string containing any relevant + * user agent information when a modern mobile browser is detected. + * Currently limited to Safari on the iPhone/iPod Touch, Nokia N-series + * devices with the WebKit-based browser, and Opera Mini. + * @property mobile + * @type string + */ + mobile: null, + + /** + * Adobe AIR version number or 0. Only populated if webkit is detected. + * Example: 1.0 + * @property air + * @type float + */ + air: 0, + + /** + * Google Caja version number or 0. + * @property caja + * @type float + */ + caja: 0 + + }, + + ua = navigator.userAgent, + + m; + + // Modern KHTML browsers should qualify as Safari X-Grade + if ((/KHTML/).test(ua)) { + o.webkit=1; + } + // Modern WebKit browsers are at least X-Grade + m=ua.match(/AppleWebKit\/([^\s]*)/); + if (m&&m[1]) { + o.webkit=parseFloat(m[1]); + + // Mobile browser check + if (/ Mobile\//.test(ua)) { + o.mobile = "Apple"; // iPhone or iPod Touch + } else { + m=ua.match(/NokiaN[^\/]*/); + if (m) { + o.mobile = m[0]; // Nokia N-series, ex: NokiaN95 + } + } + + m=ua.match(/AdobeAIR\/([^\s]*)/); + if (m) { + o.air = m[0]; // Adobe AIR 1.0 or better + } + + } + + if (!o.webkit) { // not webkit + // @todo check Opera/8.01 (J2ME/MIDP; Opera Mini/2.0.4509/1316; fi; U; ssr) + m=ua.match(/Opera[\s\/]([^\s]*)/); + if (m&&m[1]) { + o.opera=parseFloat(m[1]); + m=ua.match(/Opera Mini[^;]*/); + if (m) { + o.mobile = m[0]; // ex: Opera Mini/2.0.4509/1316 + } + } else { // not opera or webkit + m=ua.match(/MSIE\s([^;]*)/); + if (m&&m[1]) { + o.ie=parseFloat(m[1]); + } else { // not opera, webkit, or ie + m=ua.match(/Gecko\/([^\s]*)/); + if (m) { + o.gecko=1; // Gecko detected, look for revision + m=ua.match(/rv:([^\s\)]*)/); + if (m&&m[1]) { + o.gecko=parseFloat(m[1]); + } + } + } + } + } + + m=ua.match(/Caja\/([^\s]*)/); + if (m&&m[1]) { + o.caja=parseFloat(m[1]); + } + + return o; +}(); + +/* + * Initializes the global by creating the default namespaces and applying + * any new configuration information that is detected. This is the setup + * for env. + * @method init + * @static + * @private + */ +(function() { + YAHOO.namespace("util", "widget", "example"); + /*global YAHOO_config*/ + if ("undefined" !== typeof YAHOO_config) { + var l=YAHOO_config.listener,ls=YAHOO.env.listeners,unique=true,i; + if (l) { + // if YAHOO is loaded multiple times we need to check to see if + // this is a new config object. If it is, add the new component + // load listener to the stack + for (i=0;i 0) ? L.dump(o[i], d-1) : OBJ); + } else { + s.push(o[i]); + } + s.push(COMMA); + } + if (s.length > 1) { + s.pop(); + } + s.push("]"); + // objects {k1 => v1, k2 => v2} + } else { + s.push("{"); + for (i in o) { + if (L.hasOwnProperty(o, i)) { + s.push(i + ARROW); + if (L.isObject(o[i])) { + s.push((d > 0) ? L.dump(o[i], d-1) : OBJ); + } else { + s.push(o[i]); + } + s.push(COMMA); + } + } + if (s.length > 1) { + s.pop(); + } + s.push("}"); + } + + return s.join(""); + }, + + /** + * Does variable substitution on a string. It scans through the string + * looking for expressions enclosed in { } braces. If an expression + * is found, it is used a key on the object. If there is a space in + * the key, the first word is used for the key and the rest is provided + * to an optional function to be used to programatically determine the + * value (the extra information might be used for this decision). If + * the value for the key in the object, or what is returned from the + * function has a string value, number value, or object value, it is + * substituted for the bracket expression and it repeats. If this + * value is an object, it uses the Object's toString() if this has + * been overridden, otherwise it does a shallow dump of the key/value + * pairs. + * @method substitute + * @since 2.3.0 + * @param s {String} The string that will be modified. + * @param o {Object} An object containing the replacement values + * @param f {Function} An optional function that can be used to + * process each match. It receives the key, + * value, and any extra metadata included with + * the key inside of the braces. + * @return {String} the substituted string + */ + substitute: function (s, o, f) { + var i, j, k, key, v, meta, saved=[], token, + DUMP='dump', SPACE=' ', LBRACE='{', RBRACE='}', + dump; + + + for (;;) { + i = s.lastIndexOf(LBRACE); + if (i < 0) { + break; + } + j = s.indexOf(RBRACE, i); + if (i + 1 >= j) { + break; + } + + //Extract key and meta info + token = s.substring(i + 1, j); + key = token; + meta = null; + k = key.indexOf(SPACE); + if (k > -1) { + meta = key.substring(k + 1); + key = key.substring(0, k); + } + + // lookup the value + v = o[key]; + + // if a substitution function was provided, execute it + if (f) { + v = f(key, v, meta); + } + + if (L.isObject(v)) { + if (L.isArray(v)) { + v = L.dump(v, parseInt(meta, 10)); + } else { + meta = meta || ""; + + // look for the keyword 'dump', if found force obj dump + dump = meta.indexOf(DUMP); + if (dump > -1) { + meta = meta.substring(4); + } + + // use the toString if it is not the Object toString + // and the 'dump' meta info was not found + if (v.toString===OP.toString || dump>-1) { + v = L.dump(v, parseInt(meta, 10)); + } else { + v = v.toString(); + } + } + } else if (!L.isString(v) && !L.isNumber(v)) { + // This {block} has no replace string. Save it for later. + v = "~-" + saved.length + "-~"; + saved[saved.length] = token; + + // break; + } + + s = s.substring(0, i) + v + s.substring(j + 1); + + + } + + // restore saved {block}s + for (i=saved.length-1; i>=0; i=i-1) { + s = s.replace(new RegExp("~-" + i + "-~"), "{" + saved[i] + "}", "g"); + } + + return s; + }, + + + /** + * Returns a string without any leading or trailing whitespace. If + * the input is not a string, the input will be returned untouched. + * @method trim + * @since 2.3.0 + * @param s {string} the string to trim + * @return {string} the trimmed string + */ + trim: function(s){ + try { + return s.replace(/^\s+|\s+$/g, ""); + } catch(e) { + return s; + } + }, + + /** + * Returns a new object containing all of the properties of + * all the supplied objects. The properties from later objects + * will overwrite those in earlier objects. + * @method merge + * @since 2.3.0 + * @param arguments {Object*} the objects to merge + * @return the new merged object + */ + merge: function() { + var o={}, a=arguments, l=a.length, i; + for (i=0; i + * var A = function() {}; + * A.prototype.foo = 'foo'; + * var a = new A(); + * a.foo = 'foo'; + * alert(a.hasOwnProperty('foo')); // true + * alert(YAHOO.lang.hasOwnProperty(a, 'foo')); // false when using fallback + * + * @method hasOwnProperty + * @param {any} o The object being testing + * @param prop {string} the name of the property to test + * @return {boolean} the result + */ +L.hasOwnProperty = (OP.hasOwnProperty) ? + function(o, prop) { + return o && o.hasOwnProperty(prop); + } : function(o, prop) { + return !L.isUndefined(o[prop]) && + o.constructor.prototype[prop] !== o[prop]; + }; + +// new lang wins +OB.augmentObject(L, OB, true); + +/* + * An alias for YAHOO.lang + * @class YAHOO.util.Lang + */ +YAHOO.util.Lang = L; + +/** + * Same as YAHOO.lang.augmentObject, except it only applies prototype + * properties. This is an alias for augmentProto. + * @see YAHOO.lang.augmentObject + * @method augment + * @static + * @param {Function} r the object to receive the augmentation + * @param {Function} s the object that supplies the properties to augment + * @param {String*|boolean} arguments zero or more properties methods to + * augment the receiver with. If none specified, everything + * in the supplier will be used unless it would + * overwrite an existing property in the receiver. if true + * is specified as the third parameter, all properties will + * be applied and will overwrite an existing property in + * the receiver + */ +L.augment = L.augmentProto; + +/** + * An alias for YAHOO.lang.augment + * @for YAHOO + * @method augment + * @static + * @param {Function} r the object to receive the augmentation + * @param {Function} s the object that supplies the properties to augment + * @param {String*} arguments zero or more properties methods to + * augment the receiver with. If none specified, everything + * in the supplier will be used unless it would + * overwrite an existing property in the receiver + */ +YAHOO.augment = L.augmentProto; + +/** + * An alias for YAHOO.lang.extend + * @method extend + * @static + * @param {Function} subc the object to modify + * @param {Function} superc the object to inherit + * @param {Object} overrides additional properties/methods to add to the + * subclass prototype. These will override the + * matching items obtained from the superclass if present. + */ +YAHOO.extend = L.extend; + +})(); +YAHOO.register("yahoo", YAHOO, {version: "2.7.0", build: "1799"});