/**
 * @namespace
 * This namespace holds common functions, classes, constants, and utilities used on the GridMob site.
 * 
 */
gm.util = {  
	/**
	 * Returns true if a function false otherwise
	 * @param {Object} it
	 * @return {boolean}
	 */
	isFunction : function(it) {
		if (!isSafari || !(typeof it == "function" && it == "[object NodeList]")) {
			return typeof it == "function" || it instanceof Function;
		} else {	
			return false;
		}
	},

	/**
	 * Returns true if it is a JavaScript object (or an Array, a Function or null)
	 * @param {Object} it
	 * @return {boolean}
	 */
	isObject : function(it){
		return it !== undefined && (it === null || typeof it == "object" || this.isArray(it) || this.isFunction(it));
	},

	/**
	 * Checks if the passed in element is an array.
	 * @param {Object} el
	 * @return {boolean}
	 */
	isArray : function(el) {
		return el && el instanceof Array || typeof el == "array";
	},

	/**
	 * Checks if the passed in element has array properties array.  Looser description of an array than checking the typeof.
	 * @param {Object} el
	 * @return {boolean}
	 */
	isArrayLike : function(el) {
		return (el!=null && typeof(el)=="object" && typeof(el.length)=="number" && (el.length==0 || typeof((el[0])) != "undefined"));	
	},

	/**
	 * Returns true if string
	 * @param {Object} el 
	 * @return {boolean}
	 */
	isString : function(el) {
		return typeof el == "string" || el instanceof String; // Boolean
	},

	/**
	 * Checks if the passed in element is an html element
	 * 
	 * @method isHTMLElement
	 * @param  {Object}       ele
	 * @param  {String|Array} tagname  (optional) the valid tagname/s for the element to be
	 * @return {boolean}               true if an html element matching the tagname/s, false otherwise
	 */
	isHTMLElement : function(el, tagname) {
		// if the element is not an 
		if (el == null || typeof el != "object" || el.nodeName == null) {
			return false;
		}

		// if no tagname we are not comparing to anything, so return true
		if (!tagname) {return true;}

		// if the tagname is a string compare it to the elements nodename
		if (typeof tagname == "string" && tagname.toLowerCase() ==  el.nodeName.toLowerCase()) {
			return true;
		}
			
		// if we have an array of elements we want to compare to do a recursive call with the array contents
		if (this.isArray(tagname)) {
			for (var i = 0; i < tagname.length; i++) {
				// recursive call with the element to determine the contents of the array
				if (this.isHTMLElement(el,tagname[i])) {
					return true;
				}
			}
		}

		return false;
	},
    
    /**
     * Unescapes a value containing HTML markup.
     *   
     * @param {String} value  escaped value
     * @return the unescaped value
     */
    unescapeHTML : function(value) {
        return value.replace(/&([^;]+);/g, function(match, match1) { 
            switch (match1) {
                case 'lt':
                    return '<';
                case 'gt':
                    return '>';
                case 'amp':
                    return '&';
                case 'quot':
                    return '"';
                default:
                    // Assume char code.
                    if (match1.charAt(0) == '#') { match1 = match1.substring(1, match1.length); }
                    return String.fromCharCode(match1);
            }
        });
    },
    
	/**
	 * 
	 * @param {Object} value
	 */
    isEmptyString : function(value) {
        return (!(value) || (value.length == 0));
    },

	/**
	 * Function will trim spaces off a string
	 * @param {String} s  the string we want to trim
	 * @return {String}
	 */
    trim : function(s) {
		return s.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
	},
	
	/**
	 * 
	 * @param {Object} value
	 */
    capitalize : function(value) {
        return value.replace(/\w\S*/g, function(word) { return word.charAt(0).toUpperCase() + word.substr(1).toLowerCase(); });
    },
	
	
	/**
	 * Function assists in setting of transparent pngs.  accounts for ie6 mainly
	 * @param {String|HTMLElement} img   the handle to the image
	 * @param {String} src               the src of the image
	 * @param {String} mode              (optional) the mode of the image "scale" or "noscale" defaults to "noscale"
	 */
	setImgToPng : function(img,src,mode) {
		img = $(img);
		mode = mode || "noscale";
        if (isIE && isIE < 7) {
			img.src = "/cdn/beta/images/px.gif";
			img.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + src + "', sizingMethod='" + mode + "')";
        } else {
			img.src = src;
        }
	},

	/**
	 * Locates the first index of the provided value in the passed array. If the value is not found, -1 is returned.
	 * For details on this method, see: http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf
	 * @param {Array}   array
	 * @param {Object}  value
	 * @param {Integer} fromIndex  (optional) index to start searching from
	 * @param {Boolean} findLast   (optional) will return the last occurance if true is passed in
	 * @retur {int} the index of the entry in the array, or -1 if not found in the array
	 */
	indexOf : function(array, value,fromIndex,findLast){
		var i = 0, step = 1, end = array.length;
		if(findLast){
			i = end - 1;
			step = end = -1;
		}
		for(i = fromIndex || i; i != end; i += step){
			if(array[i] == value){ return i; }
		}
		return -1;
	},
	
    /**
     * Opens a window according to the given parameters.
     * 
     * @param {Object} fPage    window url
     * @param {Object} fName    window name
     * @param {Object} fWidth   window width
     * @param {Object} fHeight  window height
     * @param {Object} fScroll  whether or not to show a scroll bar
     */
    newWindow : function(fPage, fName, fWidth, fHeight, fScroll) {   
        fScroll = "yes";
		var winl = 10, wint = 10;
        var winprops = 'height='+fHeight+',width='+fWidth+',top='+wint+',left='+winl+',scrollbars='+fScroll+',directories=no,resizable=yes';
        win = window.open(fPage, fName, winprops); 
        if (parseInt(navigator.appVersion) >= 4) {
            win.focus();
        }  
        return win;
	},

	/**
	 * Dojo extends the functionality of nodes to have an addEventListener to IE.  Since we don't use some of 
	 * dojo's codebase, we have to have custom code to attach events ... that is called from their stuff 
     * @param {HTMLElement} el      the element to bind the handler to
     * @param {string}      eType   the type of event handler
     * @param {function}    fn      the callback to invoke
	 */
	addEventListener : function(el,eType,fn) {
	    if (window.addEventListener) {
            el.addEventListener(eType, fn,false);
	    } else if (window.attachEvent) {
            el.attachEvent("on" + eType, fn);
	    }
	},
	
	/**
	 * Dojo extends the functionality of nodes to have an addEventListener to IE.  Since we only use some of 
	 * dojo's codebase, we have to have custom code to attach events ... that is called from their stuff 
	 * @param {Object} el
	 * @param {Object} eType
	 * @param {Object} fn
	 */
	removeEventListener : function(el,eType,fn) {
        if (window.removeEventListener) {
            el.removeEventListener(eType, fn,false);
        } else if (window.detachEvent) {
            el.detachEvent("on" + eType, fn);
        }
	},
	
	/**
	 * Will set the style of the passed in element
	 * @param {String|HTMLNode} el       the element we are styling
	 * @param {String}          property the style property name
	 * @param {String|int}      val      the property value
	 */
	setStyle :  function(el,property,val) {
		el = $(el);
	    if (isIE) {
            switch (property) {
                case 'opacity':
                    if (this.isString(el.style.filter)) { // in case not appended
                        el.style.filter = 'alpha(opacity=' + val * 100 + ')';

                        if (!el.currentStyle || !el.currentStyle.hasLayout) {
                            el.style.zoom = 1; // when no layout or cant tell
                        }
                    }
                    break;
                case 'float':
                    property = 'styleFloat';
                default:
                    el.style[property] = val;
            }
	    } else {
            if (property == 'float') {
                property = 'cssFloat';
            }
            el.style[property] = val;
	    }
	},

	/**
	 * Returns whether or not the specified classes are a portion of the class list currently applied to the node. 
	 * @param  {DomNode|String} node
	 * @param  {String}         classStr
	 * @return {Boolean}
	 */
	hasClass : function(node,classStr){
		return ((" " + $(node).className + " ").indexOf(" " + this.trim(classStr) + " ") >= 0);  
	},
	
	/**
	 * Adds the specified classes to the end of the class list on the passed node.
	 * @param  {DomNode|String} node     the dom node or it's identifier that we want to add the class to
	 * @param  {String}         classStr the class that will be added
	 */
	addClass : function(node,classStr){
		node = $(node);
		var cls = node.className;
		if((" "+cls+" ").indexOf(" " + this.trim(classStr) + " ") < 0){
			node.className = cls + (cls ? ' ' : '') + classStr;
		}
	},
	
	/**
	 * Removes the specified classes from node.
	 * @param  {DomNode|String} node     the dom node or it's identifier that we want to add the class to
	 * @param  {String}         classStr the class that will be removed
	 */
	removeClass : function(node,classStr){
		node = $(node);
		var t = this.trim((" " + node.className + " ").replace(" " + classStr + " ", " "));
		if(node.className != t){ node.className = t; }
	},

	/**
	 * Adds a class to node if not present, or removes if present. Pass a boolean condition if you want 
	 * to explicitly add or remove.
	 * @param  {DomNode|String} node      the dom node or it's identifier
	 * @param  {String}         classStr  the class we will be toggling
	 * @param  {Boolean}        condition (optional) If passed, true means to add the class, false means to remove.
	 */
	toggleClass : function(/*DomNode|String*/node, /*String*/classStr, /*Boolean?*/condition){
		if(condition === undefined){
			condition = !this.hasClass(node, classStr);
		}
		this[condition ? "addClass" : "removeClass"](node, classStr);
	},

	/**
	 * Function will check if the provided xy point is outside of the bounds of the provided element.
	 * @method pointInBounds
	 * @param  {Array}   pXY     {x,y} position of point
	 * @param  {Object}  el      element that we are checking the region for
	 * @param  {int}     margin  the allowable margin that we will still return that the xy is inside the bounds
	 * @return {boolean}         true if the point is within the element bounds, false if outside of the element bounds
	 */
	pointInBounds : function (p,el,margin) {
		margin = margin || 0;
		var elc = this.coords(el,true);
		return (elc.x - margin < p.x && p.x < elc.x + elc.w + margin &&  elc.y - margin < p.y && p.y < elc.y + elc.h + margin);
	},
	
	
	/**
	 * Function gets the xy of the mouse from the passed in event
	 * @param {Object} ev
	 */
	getXYFromEvent : function (ev) {
		// get where the mousdown event occurred
		if (isIE) {
			// grab the x-y pos.s if browser is IE
			return {x: window.event.clientX + this.getDocumentScrollLeft(),y:window.event.clientY + this.getDocumentScrollTop()};

		} else {
			// grab the x-y pos.s if browser is other
			return {x: ev.pageX,y:ev.pageY};
		}
	},

	/**
	 * This function return the bounding box of an element relative to the page.
	 *
	 * @method coords
	 * @param  {object}   el   The element we want the bounding box for
	 * @return {object}         The array of points 
	 */
	coords : function (el) {
		var xy = this.getXY(el);
		return (!xy) ? false : {
			l : xy[0],
			t : xy[1],
			x : xy[0],
			y : xy[1],
			w : el.offsetWidth,
			h : el.offsetHeight
		};
	},

	/**
	 * Function will return the xy position of the passed in element
	 * @param {HTMLElement} el 
	 * @return {Array}         an array that holds the [x,y] position of the element
	 */
	getXY : function(el) {
		var pd,box,rootNode,pos,parentNode,accountForBody,regTest = null;
        if (isIE) {
            box = el.getBoundingClientRect();
            rootNode = el.ownerDocument;
            return [box.left + this.getDocumentScrollLeft(rootNode), box.top + this.getDocumentScrollTop(rootNode)];
        } else {
            pos = [el.offsetLeft, el.offsetTop];
            parentNode = el.offsetParent;

            // safari: subtract body offsets if el is abs (or any offsetParent), unless body is offsetParent
            accountForBody = (isSafari && el.style && el.style.position == "absolute" && el.offsetParent == el.ownerDocument.body);

			// loop through absolute positioned parents and get their offsets to add to the root xy
            if (parentNode != el) {
                while (parentNode) {
                    pos[0] += parentNode.offsetLeft;
                    pos[1] += parentNode.offsetTop;
                    if (!accountForBody && isSafari && el.style && el.style.position == "absolute") { 
                        accountForBody = true;
                    }
                    parentNode = parentNode.offsetParent;
                }
            }

			//safari doubles in this case
            if (accountForBody) { 
                pos[0] -= el.ownerDocument.body.offsetLeft;
                pos[1] -= el.ownerDocument.body.offsetTop;
            } 
            parentNode = el.parentNode;
			pd = "";
			regTest = /^(?:inline|table-row)$/i;
            // account for any scrolled ancestors
            while (parentNode.tagName && parentNode.tagName != "body" && parentNode.tagName != "html") {
                if (parentNode.scrollTop || parentNode.scrollLeft) {
                    // work around opera inline/table scrollLeft/Top bug (false reports offset as scroll)
					pd = (parentNode.style && parentNode.style.display) ? parentNode.style.display : "";
                    if (regTest.test(pd) && (!isOpera || (parentNode.style && parentNode.style.overflow !== 'visible'))) { 
                        pos[0] -= parentNode.scrollLeft;
                        pos[1] -= parentNode.scrollTop;
                    }
                }
                parentNode = parentNode.parentNode; 
            }
            return pos;
        }
	},

    /**
     * Returns the left scroll value of the document 
     * @param {HTMLDocument} document (optional) The document to get the scroll value of
     * @return {Int}  The amount that the document is scrolled to the left
     */
    getDocumentScrollLeft: function(doc) {
        doc = doc || document;
        return Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft);
    }, 

    /**
     * Returns the top scroll value of the document 
     * @param {HTMLDocument} document (optional) The document to get the scroll value of
     * @return {Int}  The amount that the document is scrolled to the top
     */
    getDocumentScrollTop: function(doc) {
        doc = doc || document;
        return Math.max(doc.documentElement.scrollTop, doc.body.scrollTop);
    },

	/**
	 * This function will tell you if the element in question will overlap the edges of the screen when 
	 * displayed at the coordinates provided.
	 *
	 * @method getPageOverlap
	 * @param  {DomNode}  el        The element we want the bounding box
	 * @param  {Object}   p         (optional) The x/y coordinates we will show the element
	 * @return {object}             Static object containing the amount the object overlaps
	 *                              the edges of the document.
	 */
	getPageOverlap : function (el,p) {
	    var v = this.getDocumentDimensions();
		var elc = this.coords(el, true);
	
	    // if position is not provided use the position of the element provided
	    if (p.x === null || p.y === null) {
	        p.x = elc.x;
	        p.y = elc.y;
	    }
	
	    // check if the element overlaps the edges
	    overlap = {
	        overTop : (p.y < v.t) ? v.t - p.y : 0,
	        overBottom :(p.y + elc.h > v.vh + v.t) ? (p.y + elc.h) - (v.vh + v.t) : 0,
	        overLeft : (p.x < v.l) ? v.l - p.x : 0,
	        overRight :(p.x + elc.w > v.vw + v.l) ? (p.x + elc.w) - (v.vw + v.l) : 0
	    };
	
	    return overlap;
	},
	    
	/**
	 * Get's all the different dimensions for the document
	 * @return {Object} object containing the values of the viewport width and height (obj.vw,obj.vh), the 
	 *                  pages scroll amount (obj.l,obj.t), and the pages width and height (obj.w,obj.h)
	 */
	getDocumentDimensions : function() {
	    var d = {};
		var dde = document.documentElement;
		var b = document.body;
	
	    // viewport
	    d.vw = (dde && dde.clientWidth)  ? dde.clientWidth  : window.innerWidth || self.innerWidth || b.clientWidth; 
	    d.vh = (dde && dde.clientHeight) ? dde.clientHeight : window.innerHeight || self.innerHeight || b.clientHeight; 
	
	    // scroll
	    d.l = (dde && dde.scrollLeft) ? dde.scrollLeft : window.pageXOffset || self.pageXOffset || b.scrollLeft; 
	    d.t = (dde && dde.scrollTop)  ? dde.scrollTop  : window.pageYOffset || self.pageYOffset || b.scrollTop; 
	
	    // page
	    d.w = (dde && dde.scrollWidth)  ? dde.scrollWidth  : (b.scrollWidth > b.offsetWidth) ? b.scrollWidth : b.offsetWidth; 
	    d.h = (dde && dde.scrollHeight) ? dde.scrollHeight : (b.scrollHeight > b.offsetHeight) ? b.scrollHeight : b.offsetHeight;
	    return d;
	},

	/**
	 * IE and FF Mac have issues with some window elements ignoring zIndexes.  This method appends a dom 
	 * node specific for those situations.  Specifically using an iframe to prevent IE5+ select boxes from 
	 * floating and using a transparent scrollable div to prevent Firefox2 Mac from having scrollbars float 
	 * to the top.
	 * 
	 * @param {Object} syncEl the dom node that we want to sync our dom hack to
	 */
	addBrowserHackDomNode : function(syncEl) {
		// init vars
		var domEl,listener = null;
	
		// get the dom node based on the browser
		domEl = this.getBrowserHackDomNode(syncEl);
		document.body.appendChild(domEl);
	
		// for ff mac listen to window events and reset overlays
		if (isFF && isMac) {
			listener = this.addFFMacListeners(domEl);
		}
		return {domEl:domEl,listener:listener};
	},
	
	
	/**
	 * Removes hack nodes that have been added
	 * @param {Object} syncEl the dom node that we want to sync our dom hack to
	 */
	removeBrowserHackDomNode : function(hackObject) {
		if (hackObject.domEl) {
			try {
				document.body.removeChild(hackObject.domEl);
			} catch (e) {}
		}
	
		// for ff mac remove listener on window events
		if (isFF && iMac && hackObject.listener) {
			this.removeFFMacListeners(hackObject.listener);
		}
	},
	
	/**
	 * Finds elements with a passed in className
	 * @param {String} className
	 * @param {String|HTMLElement} baseEl (optional) the element to look inside for the class.  if not present 
	 *                                    will default to the document body.
	 */
	getElementsByClassName : function(classname,baseEl) {
		if(!baseEl) {
			baseEl = document.getElementsByTagName("body")[0];
		} else {
			baseEl = $(baseEl);
		}
		var a = [];
		var re = new RegExp('\\b' + classname + '\\b');
		var els = baseEl.getElementsByTagName("*");
		for (var i = 0; i < els.length; i++) {
			if (re.test(els[i].className)) {
				a.push(els[i]);
			}
		}
		return a;
	},
	
	/**
	 * IE and FF Mac have issues with some window elements ignoring zIndexes.  This method returns a dom 
	 * node specific for those situations.  Specifically using an iframe to prevent IE5+ select boxes from 
	 * floating and using a transparent scrollable div to prevent Firefox2 Mac from having scrollbars float 
	 * to the top.
	 * 
	 * @param {Object}  syncEl  the dom node that we want to sync our dom hack to
	 */
	getBrowserHackDomNode : function(syncEl) {
	    var coords = this.coords(syncEl,true), hack = null;
	    // create an overflow div for firefox mac
	    if (isFF && isMac) {
	        hack = document.createElement("div");
	        hack.style.overflow = "auto";
	    }
	
	    // create an iframe for ie 6 and lower
	    if (isIE && isIE < 7) {
	        hack = document.createElement("iframe");
	        hack.src = "javascript:false;";
	        hack.style.filter = "alpha(opacity=0)";
	        hack.frameBorder = 0;
	    }
	
	    if (!hack) {
	        return;
	    }
	
	    // sync with passed in el
	    hack.style.width = coords.w + "px";
	    hack.style.height = coords.h + "px";
	    hack.style.position = "absolute";
	    hack.style.left = coords.x + "px";
	    hack.style.top = coords.y + "px";
	    hack.style.border = "none";
	    hack.style.padding = "0";
	    hack.style.margin = "0";
	    hack.style.zIndex = parseInt(syncEl.style.zIndex,10) - 2;
	    
	    return hack;            
	},

	/**
	 * Sets Focus listeners for the window to prevent scrollbars from showing through
	 * @param {DomNode} el
	 */
	addFFMacListeners : function(el) {
	    var listenerId = dojo.connect(window,'focus',function(){
	        try {
	            document.body.removeChild(el);
	            document.body.appendChild(el);
	        } catch (e) {}
	    });
	    return listenerId;
	},
	
	
	/**
	 * Removes Focus listeners for the window for the given el
	 * @param {String} listenerId  the id of the listener that we want to remove
	 */
	removeFFMacListeners : function(listenerId) {
	    dojo.disconnect(listenerId);
	},
	
	
	/**
	 * 
	 * @param {HTMLElement} el                the html element we are processing
	 * @param {String}      defaultText       the text that we are going to check
	 * @param {String}      defaultTextClass  (optional) the classname for the default text classs
	 */
	setInputDefault : function(el,defaultText,defaultTextClass) {
		defaultTextClass = defaultTextClass || "defaultText";
		if (el.value.replace(/^\s*/,'').replace(/\s*$/,'') == '') {
			el.value=defaultText;
			this.addClass(el,defaultTextClass);		
		}
	},
	
	/**
	 * 
	 * @param {HTMLElement} el                the html element we are processing
	 * @param {String}      defaultText       the text that we are going to check
	 * @param {String}      defaultTextClass  (optional) the classname for the default text classs
	 */
	clearInputDefault : function(el,defaultText,defaultTextClass) {
		defaultTextClass = defaultTextClass || "defaultText";
		if(el.value == defaultText){
			el.value='';
		}
		this.removeClass(el,defaultTextClass);
	},
	
	/**
	 * returns a list of url parameters and their values
	 */
	getURLParameters : function() {
		var loc = location.search.substring(1, location.search.length);
		var params = loc.split("&");
		var arr = [];

		for (i=0; i<params.length;i++) {
			arr[params[i].substring(0,params[i].indexOf('='))] = params[i].substring(params[i].indexOf('=')+1);
		}

		return arr;
	},
	
	/**
	 * Returns the value of the parameter if it exists
	 * @param  {String} param
	 * @return {String|Null}   the string value if it exists, null otherwise
	 * 
	 */
	getURLParameter : function(param) {
		return this.getURLParameters()[param] || null;
	}
};

/**
 * @namespace
 * Holds basic functions for classes 
 */
gm.util.Class = {
	/**
	 * Create a simple class.
	 * @method create
	 * @param {Object|Function} def   A object literal containing properties and methods to be applied
	 *                                to the class prototype. The 'initialize' method implements the
	 *                                constructor. A function is also acceptable as the definition,
	 *                                in which case the function becomes the initialize method with
	 *                                an empty prototype.
	 * @return {Function} The new class.
	 */
	create: function(def) {
		// Create base class.
		var props = typeof def == 'function' ? def.prototype : def || {};
		var cls = function() {
			// Apply instance variables (two levels, skipping functions).
			var iprops = arguments.callee.prototype;
			for (var prop in iprops) {
				if (typeof iprops[prop] == 'object' && !(iprops[prop] instanceof Array) && iprops[prop] != null) {
					var subprops = iprops[prop];
					this[prop] = {};
					for (var sprop in subprops) {
						this[prop][sprop] = subprops[sprop];
					}
				} else if (typeof iprops[prop] != 'function') {
					this[prop] = iprops[prop];
				}
			}
			// Initialize.
			this.initialize.apply(this, arguments);
		};
		// Apply prototype.
		for (var prop in props) {
			cls.prototype[prop] = props[prop];
		}
		// Apply initialization.
		if (!cls.prototype.initialize) {
			cls.prototype.initialize = typeof def == 'function' ? def : function() {};
		}
		return cls;
	},
	
	/**
	 * Extends a class/object with additional properties and methods.
	 * @method extend
	 * @param {Object|Function} dest        The destination class to extend. No existing properties or methods 
	 *                                      will be overwritten, all conflicts are skipped.
	 * @param {Array|Object|Function} src   A source object/function to copy properties and methods from. 
	 *                                      This can also be an array of sources.
	 * @param {boolean} overwriteConflicts  (optional) defaults to true.  false will prevent it from overwriting
	 *                                      base functionality.
	 * @return {Object|Function} The updated class or object.
	 */
	extend: function(dest, src, overwriteConflicts) {
		// Mix in source classes/objects.
		dest = typeof dest == 'function' ? dest.prototype : dest || {};
		if (!(src instanceof Array)) {
			src = [src];
		}
		for (var i = 0; i < src.length; i++) {
			var props = typeof src[i] == 'function' ? src[i].prototype : src[i] || {};
			for (var prop in props) {
				if (!dest[prop] || !!overwriteConflicts) {
					dest[prop] = props[prop];
				}
			}
		}
		return dest;
	},
	
	/**
	 * Inherits a new class from a parent class.
	 * @method inherit
	 * @param {Function} parent       The parent class to derive from. The constructor/initialize method 
	 *                                will automatically be called upon initializing the new class.
	 * @param {Object|Function} def   A object literal containing properties and methods to be applied
	 *                                to the class prototype. The 'initialize' method implements the
	 *                                constructor. A function is also acceptable as the definition,
	 *                                in which case the function becomes the 'initialize' method with
	 *                                an empty prototype.
	 * @return {Function} The new class.
	 */
	inherit: function(parent, def) {
		// Create destination class.
		var cls = gm.util.Class.create(def);
		gm.util.Class.extend(cls, parent);
		// Inherit parent class.
		var init = cls.prototype.initialize;
		var base = parent.prototype.initialize || parent;
		cls.prototype.initialize = function() {
			init.apply(this, arguments);
			base.apply(this, arguments);
		};
		// Set a reference to the base class.
		cls.prototype.base = parent;
		return cls;
	}
};


/**
 * @namespace 
 * This namespace contains common functions for exeucting ajax requests.
 * 
 * @static
 */
gm.util.AJAX = {

    /**
     * Synchronously requests the given url and returns the response.
     * 
     * @param {String} url     url
     * @param {Object} config  parameters used to control the request
     * @return the response
     */
    syncRequest : function(url, config) {
        // TODO: error handling
        if (!config) {
			config = { };
		}
        config.async = false;
        var req = this._createRequest(url, config);
        
        var xhr = req.xhr;
        xhr.send(null);
        
        var response = (xhr.responseXML) ? xhr.responseXML : (xhr.status == 200) ? xhr.responseText : '';
        if (req.timeout) { clearTimeout(req.timeout); }
        return response;   
    },
    
    /**
     * Asynchronously requests the given url and executes the given callback passing the response. 
     * 
     * @param {String} url         url
     * @param {Function} callback  callback that handles the request
     * @param {Object} config      parameters used to control the request
     * @return the response
     */
    asyncRequest : function(url, callback, config) {
        // TODO: error handling
        if (!config) {
			config = { };
		}
        config.async = true;
        var req = this._createRequest(url, config);

        var xhr = req.xhr;
        
        xhr.onreadystatechange = function() {
            if (xhr.readyState == 4) {
                var response = (xhr.status == 200) ? xhr.responseText : '';
                if (req.timeout) { clearTimeout(req.timeout); }
                callback(response);
            }
        };
        
        xhr.send(null);
    },
    
    /**
     * Sets up the request.
     * 
     * @param {Object} url      url
     * @param {Object} config  parameters used to control the request
     */
    _createRequest : function(url, config) {
    	// Create the request in a browser-independent manner.
        var xhr;
        
        if (window.XMLHttpRequest) {
            xhr = new XMLHttpRequest();
        } else if (window.ActiveXObject) {
	       	try {
	        	xhr = new ActiveXObject("Msxml2.XMLHTTP");
	      	} catch(e) {
	        	try {
	          		xhr = new ActiveXObject("Microsoft.XMLHTTP");
	        	} catch(e) {
	          		xhr = false;
	        	}
			}


        }

		if (!xhr) {
			return false;
		}
        
        xhr.open((config.method ? config.method.toUpperCase() : 'POST'), url, config.async);
        
        // Add a timeout handler if requested.
        var timeout;
        
        if (config.timeout) {
            timeout = setTimeout(function() { gm.util.AJAX._handleTimeout(xhr);}, config.timeout);
        }
        
        var req = {
            xhr : xhr,
            timeout : timeout
        };
        
        return req;
    },
    
    /**
     * Handles a request timeout.  
     */
    _handleTimeout : function(xhr) {
    	xhr.abort();
    }
};


/**
 * @namespace
 * This namespace holds utilities related to managing and building functionality in widgets
 */
gm.util.widget = {
	
	
	/**
	 * Will replace the provided key in the 
	 * @param {Object} txt
	 * @param {Object} key
	 * @param {Object} value
	 * @return {String}
	 */
	replace : function(txt,key,value) {
		// in the text passed in replace the keys with the string value passed in
		value = (value != null ? value : '').toString();
		return txt.replace(new RegExp("\\$\\{" + key + "\\}",'g'),value);
	},

	/**
	 * This function provides a way to provide our HTML a way to define event attachment inline without having
	 * to worry about the memory leaks associated with providing event attachment through onclick=""
	 * and similar html coding.  Since inline events typically have poor garbage collection and handle closures 
	 * poorly, we will use dojo to handle the event attachment of custom attributes.
	 * 
	 * The pattern we use here is to have a custom attribute in the html called "attachevent".  The attributes
	 * in attach event will provide keys to map to a function or set of functions as defined by the definitions
	 * file passed in.
	 * 
	 * This will effectively allow multistep event attachment with a small markup footprint, and circumvent the
	 * need for eval and other memory intensive procedures.
	 * 
	 * @example
	 * The syntax for the attribute is a set of comma delimited keys
	 * 
	 * <div attachevent="key1,key2">...</div>
	 * 
	 * The definitions object that is passed into the object will look like this:
	 * 
	 * object = {
	 *     key1 : {event:'click',fn:function() {gm.foo();}},
	 * 	   key2 : {event:'mousedown',fn:foo,context:gm}
	 * }
	 * 
	 * In the above example both key1 and key2 are examples of ways to call the same function.
	 * 
	 * @param {String|HTMLElement} baseEl  the handle to the element to start looking for events from
	 * @param {Object} mapObj              the object that maps the attachevent keys to functions
	 */
	attachEvents : function(baseEl,mapObj) {
		if(!baseEl) {
			return;
		} else if (gm.util.isString(baseEl)) {
			baseEl = $(baseEl);
		}

		var i,j,els,arr,st,def;

		// rotate through all nodes in el and attach events as needed
		els = baseEl.getElementsByTagName("*");

		// loop through all the elements in
		for (i = 0; i < els.length; i++) {
			st = els[i].getAttribute("gmattachevent");
			st = st;
			if (st) {
				st = gm.util.trim(st);
				arr = (st.indexOf(",") >= 0) ? st.split[","] : [st];
				for (j = 0; j < arr.length;j++) {
					def = mapObj[arr[j]];
					if (!def) {
						alert("No mapping for gmattachevent : " + arr[j]);
					}
					def.context = def.context || null;
					dojo.connect(els[i],def.event,def.context,def.fn);
				}
				els[i].removeAttribute("attachevent");
			}
		}
	},

	/**
	 * Format a template string with a list of replacement strings
	 * 
	 * @param {String} s        The string to run replacements on
	 * @param {Object} replace  An object literal of hashes to be replaced along with their values
	 * @return {String}         The resulting string
	 */
	template : function(s,replace) {
		for (var i in replace) {
			s = this.replace(s,i,replace[i]);
		}
		return s;
	},

	/**
	 * Function will search for a dom node with id "scriptToEval" and eval it.  Generic pattern to prevent us
	 * from having to make another request for json data associated with html.
	 */
	evalScript : function() {
		// eval the script in the scriptToEval div
		if ($('scriptToEval')) {
			// eval the passed in script and remove the node from the tree
			var s = $('scriptToEval');
			eval(s.innerHTML);
			s.parentNode.removeChild(s);
		}
	}
};