Index: openacs-4/packages/ajaxhelper/www/resources/yui/yahoo/yahoo-debug.js
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/ajaxhelper/www/resources/yui/yahoo/yahoo-debug.js,v
diff -u -r1.1 -r1.2
--- openacs-4/packages/ajaxhelper/www/resources/yui/yahoo/yahoo-debug.js	21 Oct 2006 06:15:00 -0000	1.1
+++ openacs-4/packages/ajaxhelper/www/resources/yui/yahoo/yahoo-debug.js	25 Dec 2006 16:40:04 -0000	1.2
@@ -1,68 +1,80 @@
-
 /*                                                                                                                                                      
 Copyright (c) 2006, Yahoo! Inc. All rights reserved.
 Code licensed under the BSD License:
 http://developer.yahoo.net/yui/license.txt
-version: 0.11.3
+version: 0.12.1
 */ 
-
 /**
- * The Yahoo global namespace
- * @constructor
+ * 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
  */
-window.YAHOO = window.YAHOO || {};
 
+if (typeof YAHOO == "undefined") {
+    /**
+     * The YAHOO global namespace object
+     * @class YAHOO
+     * @static
+     */
+    var YAHOO = {};
+}
+
 /**
  * Returns the namespace specified and creates it if it doesn't exist
- *
+ * <pre>
  * YAHOO.namespace("property.package");
  * YAHOO.namespace("YAHOO.property.package");
- *
+ * </pre>
  * 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:
- *
+ * <pre>
  * YAHOO.namespace("really.long.nested.namespace");
- *
+ * </pre>
  * This fails because "long" is a future reserved word in ECMAScript
  *
- * @param  {String} ns The name of the namespace
- * @return {Object}    A reference to the namespace object
+ * @method namespace
+ * @static
+ * @param  {String*} arguments 1-n namespaces to create 
+ * @return {Object}  A reference to the last namespace object created
  */
-YAHOO.namespace = function(ns) {
+YAHOO.namespace = function() {
+    var a=arguments, o=null, i, j, d;
+    for (i=0; i<a.length; ++i) {
+        d=a[i].split(".");
+        o=YAHOO;
 
-    if (!ns || !ns.length) {
-        return null;
+        // YAHOO is implied, so it is ignored if it is included
+        for (j=(d[0] == "YAHOO") ? 1 : 0; j<d.length; ++j) {
+            o[d[j]]=o[d[j]] || {};
+            o=o[d[j]];
+        }
     }
 
-    var levels = ns.split(".");
-    var nsobj = YAHOO;
-
-    // YAHOO is implied, so it is ignored if it is included
-    for (var i=(levels[0] == "YAHOO") ? 1 : 0; i<levels.length; ++i) {
-        nsobj[levels[i]] = nsobj[levels[i]] || {};
-        nsobj = nsobj[levels[i]];
-    }
-
-    return nsobj;
+    return o;
 };
 
 /**
  * Uses YAHOO.widget.Logger to output a log message, if the widget is available.
  *
- * @param  {string}  sMsg       The message to log.
- * @param  {string}  sCategory  The log category for the message.  Default
- *                              categories are "info", "warn", "error", time".
- *                              Custom categories can be used as well. (opt)
- * @param  {string}  sSource    The source of the the message (opt)
- * @return {boolean}            True if the log operation was successful.
+ * @method log
+ * @static
+ * @param  {String}  msg  The message to log.
+ * @param  {String}  cat  The log category for the message.  Default
+ *                        categories are "info", "warn", "error", time".
+ *                        Custom categories can be used as well. (opt)
+ * @param  {String}  src  The source of the the message (opt)
+ * @return {Boolean}      True if the log operation was successful.
  */
-YAHOO.log = function(sMsg, sCategory, sSource) {
-    var l = YAHOO.widget.Logger;
+YAHOO.log = function(msg, cat, src) {
+    var l=YAHOO.widget.Logger;
     if(l && l.log) {
-        return l.log(sMsg, sCategory, sSource);
+        return l.log(msg, cat, src);
     } else {
         return false;
     }
@@ -72,21 +84,61 @@
  * Utility to set up the prototype, constructor and superclass properties to
  * support an inheritance strategy that can chain constructors and methods.
  *
- * @param {function} subclass   the object to modify
- * @param {function} superclass the object to inherit
+ * @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 = function(subclass, superclass) {
-    var f = function() {};
-    f.prototype = superclass.prototype;
-    subclass.prototype = new f();
-    subclass.prototype.constructor = subclass;
-    subclass.superclass = superclass.prototype;
-    if (superclass.prototype.constructor == Object.prototype.constructor) {
-        superclass.prototype.constructor = superclass;
+YAHOO.extend = function(subc, superc, overrides) {
+    var F = function() {};
+    F.prototype=superc.prototype;
+    subc.prototype=new F();
+    subc.prototype.constructor=subc;
+    subc.superclass=superc.prototype;
+    if (superc.prototype.constructor == Object.prototype.constructor) {
+        superc.prototype.constructor=superc;
     }
+
+    if (overrides) {
+        for (var i in overrides) {
+            subc.prototype[i]=overrides[i];
+        }
+    }
 };
 
-YAHOO.namespace("util");
-YAHOO.namespace("widget");
-YAHOO.namespace("example");
+/**
+ * Applies all prototype properties in the supplier to the receiver if the
+ * receiver does not have these properties yet.  Optionally, one or more
+ * methods/properties can be specified (as additional parameters).  This
+ * option will overwrite the property if receiver has it already.
+ *
+ * @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 = function(r, s) {
+    var rp=r.prototype, sp=s.prototype, a=arguments, i, p;
+    if (a[2]) {
+        for (i=2; i<a.length; ++i) {
+            rp[a[i]] = sp[a[i]];
+        }
+    } else {
+        for (p in sp) { 
+            if (!rp[p]) {
+                rp[p] = sp[p];
+            }
+        }
+    }
+};
 
+YAHOO.namespace("util", "widget", "example");
+