    YAHOO.namespace('ext');
    YAHOO.namespace('ext.util');
    YAHOO.namespace('ext.grid');
    YAHOO.ext.Strict = (document.compatMode == 'CSS1Compat');
    YAHOO.ext.SSL_SECURE_URL = 'javascript:false';
    // for old browsers
    window.undefined = undefined;
    /**
     * @class Function
     */
     //
    /**
     * Creates a callback that passes arguments[0], arguments[1], arguments[2], ...
     * Call directly on any function. Example: <code>myFunction.createCallback(myarg, myarg2)</code>
     * Will create a function that is bound to those 2 args.
     * @return {Function} The new function
    */
    Function.prototype.createCallback = function(/*args...*/){
        // make args available, in function below
        var args = arguments;
        var method = this;
        return function() {
            return method.apply(window, args);
        };
    };

    /**
     * Creates a delegate (callback) that sets the scope to obj.
     * Call directly on any function. Example: <code>this.myFunction.createDelegate(this)</code>
     * Will create a function that is automatically scoped to this.
     * @param {Object} obj (optional) The object for which the scope is set
     * @param {<i>Array</i>} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
     * @param {<i>Boolean/Number</i>} appendArgs (optional) if True args are appended to call args instead of overriding,
     *                                             if a number the args are inserted at the specified position
     * @return {Function} The new function
     */
    Function.prototype.createDelegate = function(obj, args, appendArgs){
        var method = this;
        return function() {
            var callargs = args || arguments;
            if(appendArgs === true){
                callArgs = Array.prototype.slice.call(arguments, 0);
                callargs = callArgs.concat(args);
            }else if(typeof appendArgs == 'number'){
                callargs = Array.prototype.slice.call(arguments, 0); // copy arguments first
                var applyArgs = [appendArgs, 0].concat(args); // create method call params
                Array.prototype.splice.apply(callargs, applyArgs); // splice them in
            }
            return method.apply(obj || window, callargs);
        };
    };

    /**
     * Calls this function after the number of millseconds specified.
     * @param {Number} millis The number of milliseconds for the setTimeout call
     * @param {Object} obj (optional) The object for which the scope is set
     * @param {<i>Array</i>} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
     * @param {<i>Boolean/Number</i>} appendArgs (optional) if True args are appended to call args instead of overriding,
     *                                             if a number the args are inserted at the specified position
     * @return {Number} The timeout id that can be used with clearTimeout
     */
    Function.prototype.defer = function(millis, obj, args, appendArgs){
        return setTimeout(this.createDelegate(obj, args, appendArgs), millis);
    };
    /**
     * Create a combined function call sequence of the original function + the passed function.
     * The resulting function returns the results of the original function.
     * The passed fcn is called with the parameters of the original function
     * @param {Function} fcn The function to sequence
     * @param {<i>Object</i>} scope (optional) The scope of the passed fcn (Defaults to scope of original function or window)
     * @return {Function} The new function
     */
    Function.prototype.createSequence = function(fcn, scope){
        if(typeof fcn != 'function'){
            return this;
        }
        var method = this;
        return function() {
            var retval = method.apply(this || window, arguments);
            fcn.apply(scope || this || window, arguments);
            return retval;
        };
    };

    /**
     * Creates an interceptor function. The passed fcn is called before the original one. If it returns false, the original one is not called.
     * The resulting function returns the results of the original function.
     * The passed fcn is called with the parameters of the original function.
     * @addon
     * @param {Function} fcn The function to call before the original
     * @param {<i>Object</i>} scope (optional) The scope of the passed fcn (Defaults to scope of original function or window)
     * @return {Function} The new function
     */
    Function.prototype.createInterceptor = function(fcn, scope){
        if(typeof fcn != 'function'){
            return this;
        }
        var method = this;
        return function() {
            fcn.target = this;
            fcn.method = method;
            if(fcn.apply(scope || this || window, arguments) === false){
                return;
            }
            return method.apply(this || window, arguments);;
        };
    };

    /**
     * @class YAHOO.ext.util.Browser
     * @singleton
     */
    YAHOO.ext.util.Browser = new function(){
    	var ua = navigator.userAgent.toLowerCase();
    	/** @type Boolean */
    	this.isOpera = (ua.indexOf('opera') > -1);
       	/** @type Boolean */
    	this.isSafari = (ua.indexOf('webkit') > -1);
       	/** @type Boolean */
    	this.isIE = (window.ActiveXObject);
       	/** @type Boolean */
    	this.isIE7 = (ua.indexOf('msie 7') > -1);
       	/** @type Boolean */
    	this.isGecko = !this.isSafari && (ua.indexOf('gecko') > -1);

    	if(ua.indexOf("windows") != -1 || ua.indexOf("win32") != -1){
    	    /** @type Boolean */
    	    this.isWindows = true;
    	}else if(ua.indexOf("macintosh") != -1){
    		/** @type Boolean */
    	    this.isMac = true;
    	}
    }();

    YAHOO.print = function(arg1, arg2, etc){
        if(!YAHOO.ext._console){
            var cs = YAHOO.ext.DomHelper.insertBefore(document.body.firstChild,
            {tag: 'div',style:'width:250px;height:350px;overflow:auto;border:3px solid #c3daf9;' +
                    'background:white;position:absolute;right:5px;top:5px;' +
                    'font:normal 8pt arial,verdana,helvetica;z-index:50000;padding:5px;'}, true);
            new YAHOO.ext.Resizable(cs, {
                transparent:true,
                handles: 'all',
                pinned:true,
                adjustments: [0,0],
                wrap:true,
                draggable:(YAHOO.util.DD ? true : false)
            });
            YAHOO.ext._console = cs;
        }
        var msg = '';
        for(var i = 0, len = arguments.length; i < len; i++) {
        	msg += arguments[i] + '<hr noshade style="color:#eeeeee;" size="1">';
        }
        YAHOO.ext._console.dom.innerHTML = msg + YAHOO.ext._console.dom.innerHTML;
        YAHOO.ext._console.dom.scrollTop = 0;
    };

    YAHOO.printf = function(format, arg1, arg2, etc){
        var args = Array.prototype.slice.call(arguments, 1);
        YAHOO.print(format.replace(
          /\{\{[^{}]*\}\}|\{(\d+)(,\s*([\w.]+))?\}/g,
          function(m, a1, a2, a3) {
            if (m.chatAt == '{') {
              return m.slice(1, -1);
            }
            var rpl = args[a1];
            if (a3) {
              var f = eval(a3);
              rpl = f(rpl);
            }
            return rpl ? rpl : '';
          }));
    }

    /**
     * @class YAHOO.util.CustomEvent
     */
     //
     /**
     * Enable custom handler signature and event cancelling. Using fireDirect() instead of fire() calls the subscribed event handlers
     * with the exact parameters passed to fireDirect, instead of the usual (eventType, args[], obj). IMO this is more intuitive
     * and promotes cleaner code. Also, if an event handler returns false, it is returned by fireDirect and no other handlers will be called.<br>
     * Example:<br><br><pre><code>
     * if(beforeUpdateEvent.fireDirect(myArg, myArg2) !== false){
     *     // do update
     * }</code></pre>
     */
    YAHOO.util.CustomEvent.prototype.fireDirect = function(){
        var len=this.subscribers.length;
        for (var i=0; i<len; ++i) {
            var s = this.subscribers[i];
            if(s){
                var scope = (s.override) ? s.obj : this.scope;
                if(s.fn.apply(scope, arguments) === false){
                    return false;
                }
            }
        }
        return true;
    };

    YAHOO.extendX = function(subclass, superclass, overrides){
        YAHOO.extend(subclass, superclass);
        subclass.override = function(o){
            YAHOO.override(subclass, o);
        };
        if(!subclass.prototype.override){
            subclass.prototype.override = function(o){
                for(var method in o){
                    this[method] = o[method];
                }
            };
        }
        if(overrides){
            subclass.override(overrides);
        }
    };

    YAHOO.override = function(origclass, overrides){
        if(overrides){
            var p = origclass.prototype;
            for(var method in overrides){
                p[method] = overrides[method];
            }
        }
    };

    /**
     * @class YAHOO.ext.util.DelayedTask
     * Provides a convenient method of performing setTimeout where a new
     * timeout cancels the old timeout. An example would be performing validation on a keypress.
     * You can use this class to buffer
     * the keypress events for a certain number of milliseconds, and perform only if they stop
     * for that amount of time.
     * @constructor The parameters to this constructor serve as defaults and are not required.
     * @param {<i>Function</i>} fn (optional) The default function to timeout
     * @param {<i>Object</i>} scope (optional) The default scope of that timeout
     * @param {<i>Array</i>} args (optional) The default Array of arguments
     */
    YAHOO.ext.util.DelayedTask = function(fn, scope, args){
        var timeoutId = null;

        /**
         * Cancels any pending timeout and queues a new one
         * @param {Number} delay The milliseconds to delay
         * @param {Function} newFn (optional) Overrides function passed to constructor
         * @param {Object} newScope (optional) Overrides scope passed to constructor
         * @param {Array} newArgs (optional) Overrides args passed to constructor
         */
        this.delay = function(delay, newFn, newScope, newArgs){
            if(timeoutId){
                clearTimeout(timeoutId);
            }
            fn = newFn || fn;
            scope = newScope || scope;
            args = newArgs || args;
            timeoutId = setTimeout(fn.createDelegate(scope, args), delay);
        };

        /**
         * Cancel the last queued timeout
         */
        this.cancel = function(){
            if(timeoutId){
                clearTimeout(timeoutId);
                timeoutId = null;
            }
        };
    };

    /**
     * @class YAHOO.ext.util.Observable
     * Abstract base class that provides a common interface for publishing events. Subclasses are expected to
     * to have a property "events" with all the events defined.<br>
     * For example:
     * <pre><code>
     var Employee = function(name){
        this.name = name;
        this.events = {
            'fired' : new YAHOO.util.CustomEvent('fired'),
            'quit' : new YAHOO.util.CustomEvent('quit')
        }
     }
     YAHOO.extend(Employee, YAHOO.ext.util.Observable);
    </code></pre>
     */
    YAHOO.ext.util.Observable = function(){};
    YAHOO.ext.util.Observable.prototype = {
        /**
         * Fires the specified event with the passed parameters (minus the event name).
         * @param {String} eventName
         * @param {Object...} args Variable number of parameters are passed to handlers
         */
        fireEvent : function(){
            var ce = this.events[arguments[0].toLowerCase()];
            return ce.fireDirect.apply(ce, Array.prototype.slice.call(arguments, 1));
        },

        /**
         * Appends an event handler to this element
         * @param {String}   eventName     The type of event to listen for
         * @param {Function} handler        The method the event invokes
         * @param {<i>Object</i>}   scope  (optional) The scope (this object) for the handler
         * @param {<i>boolean</i>}  override (optional) If true, scope becomes the scope
         */
        addListener : function(eventName, fn, scope, override){
            eventName = eventName.toLowerCase();
            if(!this.events[eventName]){
                // added for a better message when subscribing to wrong event
                throw 'You are trying to listen for an event that does not exist: "' + eventName + '".';
            }
            this.events[eventName].subscribe(fn, scope, override);
        },

        /**
         * Appends an event handler to this element that is delayed the specified number of milliseconds.
         * @param {String}   eventName     The type of event to listen for
         * @param {Function} handler        The method the event invokes
         * @param {<i>Object</i>}   scope  (optional) The scope (this object) for the handler
         * @param {<i>Number</i>}  delay (optional) The number of milliseconds to delay
         * @return {Function} The wrapped function that was created (can be used to remove the listener)
         */
        delayedListener : function(eventName, fn, scope, delay){
            var newFn = function(){
                setTimeout(fn.createDelegate(scope, arguments), delay || 1);
            }
            this.addListener(eventName, newFn);
            return newFn;
        },

        /**
         * Removes a listener
         * @param {String}   eventName     The type of event to listen for
         * @param {Function} handler        The handler to remove
         * @param {<i>Object</i>}   scope  (optional) The scope (this object) for the handler
         */
        removeListener : function(eventName, fn, scope){
            this.events[eventName.toLowerCase()].unsubscribe(fn, scope);
        },

        /**
         * Removes all listeners for this object
         */
        purgeListeners : function(){
            for(var evt in this.events){
                if(typeof this.events[evt] != 'function'){
                     this.events[evt].unsubscribeAll();
                }
            }
        }
    };
    YAHOO.ext.util.Observable.prototype.on = YAHOO.ext.util.Observable.prototype.addListener;

    /**
     * @class YAHOO.ext.util.Config
     * Class with one useful method
     * @singleton
     */
    YAHOO.ext.util.Config = {
        /**
         * Copies all the properties of config to obj.
         * @param {Object} obj The receiver of the properties
         * @param {Object} config The source of the properties
         * @param {Object} defaults A different object that will also be applied for default values
         * @return {Object} returns obj
         */
        apply : function(obj, config, defaults){
            if(defaults){
                this.apply(obj, defaults);
            }
            if(config){
                for(var prop in config){
                    obj[prop] = config[prop];
                }
            }
            return obj;
        }
    };

    if(!String.escape){
        String.escape = function(string) {
            return string.replace(/('|\\)/g, "\\$1");
        };
    };

    String.leftPad = function (val, size, ch) {
        var result = new String(val);
        if (ch == null) {
            ch = " ";
        }
        while (result.length < size) {
            result = ch + result;
        }
        return result;
    };

    // workaround for Safari 1.3 not supporting hasOwnProperty
    if(YAHOO.util.Connect){
        YAHOO.util.Connect.setHeader = function(o){
    		for(var prop in this._http_header){
    		    // if(this._http_header.hasOwnProperty(prop)){
    			if(typeof this._http_header[prop] != 'function'){
    				o.conn.setRequestHeader(prop, this._http_header[prop]);
    			}
    		}
    		delete this._http_header;
    		this._http_header = {};
    		this._has_http_headers = false;
    	};
    }

Copyright © 2006 Jack Slocum. All rights reserved.