/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/
 * Bivia Utilities, v2.1.1
 * (c) 2005 bivia.com
 * created by Ben Curtis of bivia.com, February 22 2005
 * objectified, Decemeber 22, 2005
 *   - event object largely inspired/ported from Dean Edwards's events
 *     http://dean.edwards.name/my/events.js
 * enhanced domready event handling, September 20, 2006
 *   - ref: http://dean.edwards.name/weblog/2006/06/again/
 *
 * $Id$
 *~~~~*/


// set defaults for this file, which may have already been configured
if (!Conf) var Conf = {};
Conf.debug = Conf.debug || false; // note: setting to "true" here cannot be overridden by a "false" somewhere else
Conf.js_path = Conf.js_path || '/js/';
Conf.src_img_clear = Conf.src_img_clear || '/js/bv/clear.gif';
Conf.ajax_request_timeout = Conf.ajax_request_timeout || 30;
Conf.ajax_response_timeout = Conf.ajax_response_timeout || 30;



var bv = {
	tickBase : new Date(),
	initialized : false,
	init : function () {
		bv.initialized = new Date();
		bv.debug.init();
		bv.css.init();
		bv.dom.init();
		bv.ajax.init();
	}, // END init

	bv_guid : 1,
	guid_counter : 2, // 0 is reserved, bv.bv_guid == 1
	getNewGuid : function() { return bv.guid_counter++; },
	getId : function (el,base) {
		if (!el.id) {
			var b = (base) ? base : "bv";
			el.id = b + bv.getNewGuid();
		}
		return el.id;
	},
	
	debug : {
		initialized : false,
		init : function () {
			bv.debug.initialized = new Date();
			if (Conf['debug']) {
				bv.event.add(window, 'domready', function () { bv.debug.msg('domready','debug'); });
				bv.event.add(window, 'domready', function () { bv.debug.msg('domready (prioritized)','debug'); }, "priority");
				bv.event.add(window, 'load', function () { bv.debug.msg('page loaded','debug'); });
				bv.event.add(window, 'load', bv.debug.make);
				bv.debug.win = window.open('', '_blank');
				bv.debug.msg('init','debug');
			} else {
				bv.debug.msg = function () { };
			}
			if (!window.d) window.d = bv.debug.msg;
		},
		cnt : 1,
		msgList : { debug : ['script-parse [event #0 :: msg @ 0s]'] },
		msgWait : null,
		msg : function(Msg,Cat) {
			if (bv.debug.msgWait) clearTimeout(bv.debug.msgWait);
			if (!Cat) Cat = 'unspecified';
			if (!bv.debug.msgList[Cat])
				bv.debug.msgList[Cat] = new Array();
			var Now = new Date();
			bv.debug.msgList[Cat].push(Msg +' [event #'+ bv.debug.cnt++ +' :: msg @ '+ ((Now.getTime() - bv.tickBase.getTime()) /1000) +'s]');
			bv.debug.msgWait = setTimeout('bv.debug.make();', 1000);
		}, // END debug.msg
		make : function() {
			if (!bv.dom.initialized) return;
			var Alert = '<ul>';
			for (var Cat in bv.debug.msgList) {
				if (typeof Cat != "string" || (typeof bv.debug.msgList[Cat] != "object" || !bv.debug.msgList[Cat].length)) continue;
				Alert += '<li>'+ Cat +'<ol>';
				for (var xx=0; xx<bv.debug.msgList[Cat].length; xx++)
					Alert += '<li>'+ bv.debug.msgList[Cat][xx] +'</li>';
				Alert += '</ol></li>';
			}
			var Now = new Date();
			Alert += '</ul><br />-- end tick count: '+ ((Now.getTime() - bv.tickBase.getTime()) /1000) +'s --';
			if (bv.debug.win) {
				bv.debug.win.document.open();
				bv.debug.win.document.write(Alert);
				bv.debug.win.document.close();
			}
		} // END debug.make
	},

	event : {
		add : function(el, evt, fn, prioritize) {
			if (evt == 'domready') el = window;
			if (typeof el == "string") el = document.getElementById(el);
			if (!el) return;
			if (evt == 'domready') {
				if (prioritize) bv.dom.readyList.unshift(fn);
				else bv.dom.readyList.push(fn);
				if (bv.dom.initialized)
					bv.dom.ready('event.add'); // do not call function directly, because you want it executed in order
			} else { // start Dean Edwards-port code
				if (!fn.bv_guid) fn.bv_guid = bv.getNewGuid();
				if (!el.bv_events) el.bv_events = {};
				if (!el.bv_events[evt]) {
					el.bv_events[evt] = {};
					if (el["on" + evt]) { // store any previously-assigned handlers
						el.bv_events[evt][0] = el["on" + evt];
					}
				}
				el.bv_events[evt][fn.bv_guid] = fn;
				el["on" + evt] = bv.event.handle;
			}
		}, // END event.add
		remove : function(el, evt, fn) {
			if (el.events && el.bv_events[evt] && fn.bv_guid)
				delete el.bv_events[evt][fn.bv_guid];
		}, // END event.remove
		handle : function(e) {
			var Rtn = true;
			e = e || bv.event.fixEvent(window.event);
			for (var ii in this.bv_events[e.type]) {
				this.bv_handleEvent = this.bv_events[e.type][ii];
				if (this.bv_handleEvent(e) === false)
					Rtn = false;
			}
			return Rtn;
		}, // END event.handle
		fixEvent : function (event) {
			if (!event) { // error thrown on unload?
				event = { type : 'unknown' };
			}
			// add W3C standard event methods
			event.preventDefault = bv.event.fixEvent_preventDefault;
			event.stopPropagation = bv.event.fixEvent_stopPropagation;
			return event;
		},
		fixEvent_preventDefault : function() {
			this.returnValue = false;
		},
		fixEvent_stopPropagation : function() {
			this.cancelBubble = true;
		}

	}, // END event

	dom : {
		initialized : false,
		init : function () {
			bv.dom.initialized = false; // not initialized until dom.ready is run
			if (document.addEventListener) {
				document.addEventListener('DOMContentLoaded', bv.dom.ready, false); // Gecko-based browsers, Opera 9+
			} else {
				/*@cc_on @*/
				/*@if (@_win32)
				document.write('<scr'+'ipt id="__ie_onload" defer="defer" sr'+'c="javascript:false;"><\/script>');
				var script = document.getElementById("__ie_onload");
				script.onreadystatechange = function() {
					if (this.readyState == "complete") {
						bv.dom.ready(); // call the domready handler
					}
				};
				/*@end @*/
			}

			if (/WebKit/i.test(navigator.userAgent)) { // Safari
				var _timer = setInterval(function() {
					if (/loaded|complete/.test(document.readyState)) {
						bv.dom.ready(); // call the onload handler
						clearInterval(_timer);
					}
				}, 10);
			}

			bv.event.add(window, 'load', bv.dom.ready); // fail-safe fire onload, in case the above hangs
			bv.event.add(window, 'unload', function(){ window.bv = null; } ); // clean up after yourself
			if (!document.documentElement) document.documentElement = document.getElementsByTagName('html')[0];
			bv.css.addClass(document.documentElement, 'domCapable domLoading');
		}, // END dom.init

		readyList : [
			function () {
				bv.dom.initialized = new Date();
				if (bv.css && bv.css.addClass)
					bv.css.addClass(document.documentElement, 'domReady');
				if (bv.css && bv.css.removeClass)
					bv.css.removeClass(document.documentElement, 'domLoading');
			}
		],
//		readyDeferList : [],
		ready : function() {
			while (this.E = bv.dom.readyList.shift()) // deletes as it goes
				this.E(); // note: may safely support multiple, simultaneous firings
//			while (this.E = bv.dom.readyDeferList.shift()) this.E(); 
		}, // END dom.ready

		getElementsByClassName : function (el,TagsIn,Class) {
			var rtn = [];
			if (! el || ! el.getElementsByTagName) return rtn;
			var It = "\\b"+Class+"\\b";
			var Tags = TagsIn.split(",");
			for (var xx=0; xx<Tags.length; xx++) {
				var Els = (el.getElementsByTagName) ? el.getElementsByTagName(Tags[xx]) : el.all;
				for (var ii=0; ii<Els.length; ii++) {
					if (Els[ii].className.match(It))
						rtn[rtn.length] = Els[ii];
				}
			}
			return rtn;
		},
		getChildNodesOfType : function (el,TagsIn) {
			var rtn = [];
			TagsIn = TagsIn.toUpperCase();
			for (var xx=0; xx<el.childNodes.length; xx++)
				if ((","+TagsIn+",").indexOf(","+ el.childNodes[xx].nodeName +",") != -1)
					rtn[rtn.length] = el.childNodes[xx];
			return rtn;
		}
	}, // END dom
	
	css : {
		initialized : false,
		init : function () {
			bv.css.initialized = new Date();
			bv.css.makeRuleSheet();
		},
		
		ruleSheet : null,
		makeRuleSheet : function () {
// deactivate until Safari bug is squashed
return;
/*
			var ruleSheet = document.createElement('style');
			ruleSheet.type = 'text/css';
			document.getElementsByTagName('head')[0].appendChild(ruleSheet);
			bv.css.ruleSheet = document.styleSheets[document.styleSheets.length -1] || ruleSheet;
*/
			bv.css.ruleSheet = document.styleSheets[document.styleSheets.length -1];
			if (!bv.css.ruleSheet.rules) // make Mozilla conform to IE and Safari
				bv.css.ruleSheet.rules = bv.css.ruleSheet.cssRules;
		},
		insertRule : function (selector, declaration) {
// deactivate until Safari bug is squashed
return;
			var index = bv.css.ruleSheet.rules.length;
			if (bv.css.ruleSheet.insertRule)
				bv.css.ruleSheet.insertRule(selector +'{'+ declaration +'}', index);
			else bv.css.ruleSheet.addRule(selector, declaration,index);
/* 
	annoying Safari bug; seems it won't render a new style rule to the page 
	unless you change one of its properties first
*/
			bv.css.ruleSheet.rules[index].style.orphans = 'inherit';
			return index;
		}, // END css.insertRule
		deleteRule : function (selector) {
// deactivate until Safari bug is squashed
return;
			for (var xx=0; xx<bv.css.ruleSheet.rules.length; xx++)
				if (bv.css.ruleSheet.bv_rules[xx].selectorText.toLowerCase() == selector)
					bv.css.deleteRuleByIndex(xx);
		}, // END css.deleteRule
		deleteRuleByIndex : function (index) {
// deactivate until Safari bug is squashed
return;
			if (bv.css.ruleSheet.deleteRule)
				bv.css.ruleSheet.deleteRule(index);
			else bv.css.ruleSheet.removeRule(index);
		}, // END css.deleteRuleByIndex

		addClass : function (el,nm) {
			var regex = new RegExp("\\b"+nm+"\\b");
			if (!el.className.match(regex))
				el.className = bv.string.trim(el.className +" "+ nm, true);
		}, // END style.addClass
		removeClass : function (el,nm) {
			var regex = new RegExp("\\b"+nm+"\\b", "g");
			el.className = bv.string.trim(el.className.replace(regex, ''), true);
		}, // END css.removeClass

		getValue : function (el,prop) {
			if (document.defaultView && document.defaultView.getComputedStyle) {
				return document.defaultView.getComputedStyle(el,'').getPropertyValue(prop);
			} else {
				var propCased = bv.string.camelCase(prop);
				if (el.currentStyle) {
					return el.currentStyle[propCased];
				} else return el.style[propCased];
			}
		},
		getOffset : function (el,base) { // no base = offset from parent
			// IE will treat the offset as to the parentNode; Moz refers all to the body element
			// so if we're not finding an offset relative to a base, take a shortcut for IE:
			if (!base && el.offsetParent == el.parentNode) {
				return { top : el.offsetTop, left : el.offsetLeft };
			} else if (!base) base = el.parentNode;
//			var elOffset   = bv.css.getOffsetFromRoot(el);
//			var baseOffset = bv.css.getOffsetFromRoot(base);
			return {
				top  : el.offsetTop  - base.offsetTop,
				left : el.offsetLeft - base.offsetLeft
			};
		},
		getOffsetFromRoot : function (el) {
			var offset = { top : 0, left : 0};
			while (el) {
				offset.top  += el.offsetTop;
				offset.left += el.offsetLeft;
				el = el.offsetParent;
			}
			return offset;
		},
		getWindowSize : function () {
			if (typeof(window.innerWidth) == 'number') {
				return {
					w : window.innerWidth,
					h : window.innerHeight
				};
			} else {
				if (window.document.documentElement && window.document.documentElement.clientWidth) {
					return {
						w : window.document.documentElement.clientWidth,
						h : window.document.documentElement.clientHeight
					};
				} else {
					if (window.document.body && window.document.body.clientWidth) {
						return {
							w : window.document.body.clientWidth,
							h : window.document.body.clientHeight
						};
//							w : window.document.document.body.clientWidth,
//							h : window.document.document.body.clientHeight
					}
				}
			}
			return false;
		},
		opacity : {
			get : function (el) {
				var Style = null;
				var Alpha = 1;
				if (typeof el.bv_opacity == 'number')
					Alpha = el.bv_opacity;
				else if (Style = bv.css.getValue(el, 'opacity'))
					Alpha = parseFloat(Style);
				else if (Style = bv.css.getValue(el, '-moz-opacity'))
					Alpha = parseFloat(Style);
				else if (el.filters && el.filters.length && el.filters.alpha)
					Alpha = parseFloat(el.filters.alpha.opacity) /100;
				if (Alpha >= 0.99999) Alpha = 1; // unmask masked values
				if (Alpha <= 0.00001) Alpha = 0; // unmask masked values
				return Alpha;
			},
			set : function (el,Alpha) {
				if (Alpha > 0.99) Alpha = 0.99999; // mask incoming 1 to prevent fully-visible flickering transitions
				if (Alpha < 0.01) Alpha = 0.00001; // mask incoming 0 to prevent fully-invisible flickering transitions
				el.bv_opacity = parseInt(Alpha *100000) /100000; // helps speed getter; needed for Safari in some cases
				el.style.opacity = el.bv_opacity;
				el.style.MozOpacity = el.bv_opacity;
				el.style.KHTMLOpacity = el.bv_opacity;
				if (el.filters && !el.filters.alpha) // if this hasn't been declared yet as a style, it's not a filter object
					el.style.filter += ' alpha(opacity='+ (el.bv_opacity *100) +')'; // append to prevent overwriting previous filters
				if (el.filters && el.filters.length && el.filters.alpha)
					el.filters.alpha.opacity = el.bv_opacity *100;
				if (el.bv_opacity >= 0.99999) el.bv_opacity = 1; // unmask masked values
				if (el.bv_opacity <= 0.00001) el.bv_opacity = 0; // unmask masked values
				return el.bv_opacity;
			},
			adjustBy : function (el,AlphaDelta) {
				if ((""+AlphaDelta).charAt((""+AlphaDelta).length -1) == "%") {
					var Pct = parseFloat(AlphaDelta) /100;
					AlphaDelta = (Pct >= 0) ? // round up/down away from zero
						Math.ceil((1 - bv.css.opacity.get(el)) * Pct) :
						Math.floor(bv.css.opacity.get(el) * Pct);
				}
				return bv.css.opacity.set(el, bv.css.opacity.get(el) + parseFloat(AlphaDelta));
			}
		}
	}, // END css
	
	ajax : {
		isAvailable : false,
		index : 1,
		calls : [],
		groundState : [],
		historian : null,
		historicRecord : {},
		hashWas : self.location.hash,
		lastToGo : { id:null, at:new Date() },
		
		init : function () {
			if (bv.ajax.initIo()) {
				bv.ajax.isAvailable = true;
//				bv.event.add(window, 'domready', bv.ajax.history.init, 'priority');
			}
		},
		
		addHistory : function () {},
		history : {
			init : function () {
				if (!bv.ajax.historian) {
					if (document.all) {
						var bb = document.createElement('iframe');
						bb.id = 'bvAjaxHistorian';
						bb.height = 1;
						bb.width = 1;
						bb.style.visibility = 'hidden';
						bb.style.position = 'absolute';
						document.getElementsByTagName('body')[0].appendChild(bb);
						bv.ajax.historian = bb.contentWindow;
						bv.ajax.addHistory = function (id) {
							bv.ajax.historian.document.open();
							bv.ajax.historian.document.write('<script type="text/javascript">');
							bv.ajax.historian.document.write('parent.location.hash = "'+ id +'";');
							bv.ajax.historian.document.write('\<\/\scr\ipt>');
							bv.ajax.historian.document.close();
						}
					// start a history for Win IE, which ignores the first document
						bv.ajax.addHistory(self.location.hash);
					} else {
						bv.ajax.historian = {};
						bv.ajax.addHistory = function (id) {
							self.location.hash = id;
						};
					}
					bv.ajax.history.pollTimer = setInterval('bv.ajax.history.poll();', 221);
					bv.ajax.history.poll();
				}
			}, // END ajax.history.init
		
			addToGround : function (fn) {
				bv.ajax.history.init();
				if (typeof fn == 'function')
					bv.ajax.groundState.push(fn);
			},
			goToGround : function () {
				for (var xx=0; xx<bv.ajax.groundState.length; xx++)
					bv.ajax.groundState[xx]();
			},
			pollTimer : null,
			poll : function () {
				if (self.location.hash != bv.ajax.hashWas) {
					bv.ajax.hashWas = self.location.hash;
					var id = (bv.ajax.hashWas.indexOf('#') == 0) ? bv.ajax.hashWas.substring(1) : bv.ajax.hashWas;
					bv.ajax.history.go(id);
				}
			}, // END ajax.history.poll
			make : function (id, call) {
				bv.ajax.history.init();
				if (bv.ajax.historian) {
					while (bv.ajax.historicRecord[id]) id = id + bv.getNewGuid();
					bv.ajax.historicRecord[id] = call;
					bv.ajax.addHistory(id);
				}
			}, // END ajax.history.make
			go : function (id) {
			// make sure we didn't just go here
				if (bv.ajax.lastToGo.id == id) {
					var Now = new Date();
					if (Now.getTime() - bv.ajax.lastToGo.at.getTime() < 1000)
						return false;
				}
				bv.ajax.lastToGo = { id:id, at:new Date() };
				if (bv.ajax.historicRecord[id] && typeof bv.ajax.historicRecord[id] == 'function')
					bv.ajax.historicRecord[id]();
				else bv.ajax.history.goToGround();
			}
		}, // END ajax.history
		
		initIo : function () {
			var Rtn = false;
			if (window.XMLHttpRequest) {
				Rtn = new XMLHttpRequest();
			} else if (window.ActiveXObject) {
				try {
					Rtn = new ActiveXObject("Msxml2.XMLHTTP");
				} catch (e) {
					try {
						Rtn = new ActiveXObject("Microsoft.XMLHTTP");
					} catch (e) {
						Rtn = false;
					}
				}
			}
			return Rtn;
		}, // END ajax.initIo

		makeCallback : function (callback) {
			var Rtn = {
				success : bv.ajax.respSuccess,
				loading : bv.ajax.respLoading,
				error   : bv.ajax.respError,
				timeout : bv.ajax.respTimeout
			};
			if (typeof callback == 'function')
				Rtn.success = callback;
			else if (typeof callback == 'object') {
				for (var Prop in callback)
					Rtn[Prop] = callback[Prop];
			}
			return Rtn;
		}, // END ajax.makeCallback

		setup : function (callback, expectXML, avoidCache, addHeaders, followOnRedirect, requestTimeout, responseTimeout) {
			var cb = bv.ajax.makeCallback(callback);

			var http = {
				index : bv.ajax.index++,
				callback : cb,
				expectXML : (expectXML !== false) ? true : false,
				avoidCache : avoidCache || false,
				addHeaders : (typeof addHeaders != 'object') ? {} : addHeaders,
				followOnRedirect : (followOnRedirect !== false) ? true : false,
				requestTimeout : (typeof requestTimeout != 'number') ? parseFloat(Conf.ajax_request_timeout) : parseFloat(requestTimeout),
				requestTimer : null,
				responseTimeout : (typeof responseTimeout != 'number') ? parseFloat(Conf.ajax_response_timeout) : parseFloat(responseTimeout),
				responseTimer : null,
				hasBegunLoading : false,
				checkState : bv.ajax.checkState,
				redirect : bv.ajax.redirect,
				go : bv.ajax.go
			}
			http.io = bv.ajax.initIo();

			bv.ajax.calls[http.index] = http;
			return http;
		}, // END ajax.setup
		
		respSuccess : function () {},
		respLoading : function () {},
		respError : function () {},
		respTimeout : function () { this.io.abort(); this.callback.error(); },
		
		redirect : function () {
			/*
				use the properties of the object and the Location header
				to redirect the request to the new location
				(need a new io object)
			*/
		},
		
		checkState : function () {
			if (this.requestTimer) clearTimeout(this.requestTimer);
			if (this.io.readyState == 1) {
				if (!this.hasBegunLoading)
					this.callback.loading();
				this.hasBegunLoading = true;
				this.responseTimer = setTimeout("bv.ajax.calls["+ this.index +"].callback.timeout();", 1000* this.responseTimeout);
			} else if (this.io.readyState == 4) {
				if (this.responseTimer) clearTimeout(this.responseTimer);
				this.hasBegunLoading = true;
				if (this.io.status == 200) {
					this.callback.success();
				} else if (this.io.status > 299 && this.io.status < 400) {
					this.redirect();
				} else if (this.io.callback[this.io.status]) {
					this.io.callback[this.io.status](this.io.statusText);
				} else {
					this.io.callback.error(this.io.status, this.io.statusText);
				}
			}
		}, // END ajax.checkState
		
		go : function (url, content) {
			this.io.abort();
			this.hasBegunLoading = false;
			this.requestTimer = setTimeout("bv.ajax.calls["+ this.index +"].callback.timeout();", 1000* this.requestTimeout);
			this.io.onreadystatechange = this.checkState;
			if (content) {
				this.io.open("POST", url, true);
				this.io.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
				this.io.send(bv.string.makeKeyValueString(content));
			} else {
				if (this.avoidCache)
					url = bv.string.appendQueryString(url, "ord="+ Math.random());
				this.io.open("GET", url, true);
				this.io.send(null);
			}
		}, // END ajax.go
	
		pronto : function (url, callback) {
			var http = { url : url };
			http.io = bv.ajax.initIo();
			if (!http.io) return false;
			http.callback = bv.ajax.makeCallback(callback);
			http.hasBegunLoading = false;
	
			http.io.onreadystatechange = function () {
				if (http.io.readyState == 1) {
					if (!http.hasBegunLoading)
						http.callback.loading(http);
					http.hasBegunLoading = true;
				} else if (http.io.readyState == 4) {
					http.hasBegunLoading = true;
					if (http.io.status == 200) {
						http.callback.success(http.io.responseText, http.io.responseXML, http);
					} else if (http.callback[http.status]) {
						http.callback[http.io.status](http.io.statusText, http);
					} else {
						http.callback.error(http.io.status, http.io.statusText, http);
					}
				}
			}
	
	// gotta remember to check for memory leaks...
	
			http.io.open("GET", url, true);
			http.io.setRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT"); // avoid the cache
			http.io.send(null);
			return http;
		} // END prontoAjax
	}, // END ajax
	
	string : {
		trim : function (s,dedupe) {
			// Mac IE chokes on the '?'; you can break this into two replaces for Mac IE compatibility
			s = s.replace(/^[\t\r\n\s]*(.*?)[\t\r\n\s]*$/, '$1');
			if (dedupe) // reduce internal runs of whitespace
				s = s.replace(/[\t\r\n\s]+/g, ' ');
			return s;
		},
		camelCase : function (s) {
			var bits = s.split("[- ]+");
			for (var xx=1; xx<bits.length; xx++)
				if (bits[xx].length)
					bits[xx] = bits[xx].charAt(0).toUpperCase() + bits[xx].substring(1);
			return bits.join('');
		},
		stripHTML : function (s) {
			return s.replace(/<\/?\w+.*?>/g,'');
		},
		parseKeyValueString : function (s,d) {
			if (!d) d = "|"; // delimiter for multiple values with the same key
			while (s.charAt(0) == "?") s = s.substring(1);
			var Pairs = s.split(/\&(amp;)?/);
			var Rtn = {};
			for (var xx=0; xx<Pairs.length; xx++) {
				var NameValue = Pairs[xx].split("=");
				if (Rtn[unescape(NameValue[0])])
					Rtn[unescape(NameValue[0])] += d;
				else
					Rtn[unescape(NameValue[0])] = '';
				Rtn[unescape(NameValue[0])] += Rtn[unescape(NameValue[1])]
			}
			return Rtn;
		},
		makeKeyValueString : function (obj, escapeAmp, delimiter, separater) {
			var amp = (escapeAmp) ? "&amp;" : "&";
			var d = delimiter || amp;
			var s = separater || "=";
			var Arr = [];
			for (var Prop in obj)
				Arr.push(escape(Prop) + s + escape(obj[Prop]));
			return Arr.join(d);
		},
		appendQueryString : function (url, string, escapeAmp) {
			var amp = (escapeAmp) ? "&amp;" : "&";
			var pre = (url.indexOf("?") != -1) ? amp : "?";
			return url + pre + string;
		}
	}, // END string
	
	data : {
		isEmailFormat : function (str) {
			return /^[^\s]@[^\s]\.\w{2,}$/.test(str);
		}
	}, // END form
	
	cookie : {
		get : function (name) {
		
		},
		set : function (name, value, path, expires, domain) {
		
		},
		verifyAccepted : function () {}
	},
	
	array : {
		shuffle : function (a) {
			if (a.length < 2) return a;
			var Last = a[a.length -1]; // store the current last element
			do a = a.sort(bv.utility.sortRandom);
			while (Last == a[0]); // repeat until the new first is not the old last
			return a;
		}
	}, // END array

	utility : {
		sortRandom : function (a,b) {
			if (Math.random() > 0.5) return 1;
			else return -1;
		}
	},

	complete : true
}; // END bv declaration
bv.init();








////////////////


var bvDimForm = {

	init : function (el) { // verify ability, find targetted lists
		if (!bv) return; // require bv_utilities.js
		var Trg = (el) ? el : document;
		var Els = bv.dom.getElementsByClassName(Trg, 'input', 'bvDimmable');
		for (var xx=0; xx<Els.length; xx++) {
			Els[xx].bvDimForm_txt = Els[xx].getAttribute('title');
			Els[xx].title = '';
			Els[xx].bvDimForm_dim = bvDimForm.dim;
			Els[xx].bvDimForm_nodim = bvDimForm.nodim;
			bv.event.add(Els[xx], 'blur', Els[xx].bvDimForm_dim);
			bv.event.add(Els[xx], 'focus', Els[xx].bvDimForm_nodim);
			if (!Els[xx].form.bvDimForm_index) {
				Els[xx].form.bvDimForm_index = [];
				Els[xx].form.bvDimForm_nodimAll = bvDimForm.nodimAll;
				bv.event.add(Els[xx].form, 'submit', Els[xx].form.bvDimForm_nodimAll);
			}
			Els[xx].form.bvDimForm_index.push(Els[xx]);
			Els[xx].bvDimForm_dim();
		}
	},
	
	nodimAll : function () {
		for (var xx=0; xx<this.bvDimForm_index.length; xx++) {
			this.bvDimForm_index[xx].bvDimForm_nodim();
		}
	},
	
	dim : function () {
		if (this.value == '' || this.value == this.bvDimForm_txt) {
			try {
				if (this.type == 'password') {
					this.bvDimForm_origType = 'password';
					this.type = 'text';
				}
				bv.css.addClass(this, 'bvDim');
				this.value = this.bvDimForm_txt;
			} catch (e) {}
		}
	},
	
	nodim : function () {
		try {
			if (this.bvDimForm_origType) {
				this.type = 'password';
			}
			bv.css.removeClass(this, 'bvDim');
			if (this.value == this.bvDimForm_txt) {
				this.value = '';
			}
		} catch (e) {}
	}

}

if (bv && bv.event) bv.event.add(window, "domready", bvDimForm.init);




var bvFormOther = {

	init : function (el) { // verify ability, find targetted lists
		if (!bv) return; // require bv_utilities.js
		var Trg = (el) ? el : document;
		var Els = bv.dom.getElementsByClassName(Trg, 'fieldset', 'bvFormOther');
		for (var xx=0; xx<Els.length; xx++) {
			var Out = bv.dom.getElementsByClassName(Els[xx], 'select,input', 'bvFormOtherOut')[0];
			var In  = bv.dom.getElementsByClassName(Els[xx], 'select,input,textarea,button', 'bvFormOtherIn')[0];
			Out.bvFormOther = Els[xx];
			In.bvFormOther  = Els[xx];
			Els[xx].bvFormOther = {
				chooser : Out,
				other : In
			};
			bv.event.add(Out, 'change', bvFormOther.choose);
			bv.event.add(In, 'blur', bvFormOther.offer);
			bv.event.add(In, 'keypress', bvFormOther.checkAcceptance);
			bv.css.addClass(Els[xx], 'bvFormOtherHide');
			
		// when people return to the page with the back button
		// the 'other' field is populated, but the js-written text is not
			if (In.value.length) {
				for (var xx=Out.options.length -1; xx>=0; xx--) { // backwards, cuz 'other' is usually last
					if (Out.options[xx].value == 'other') {
						Out.options[xx].text = In.value;
						break;
					}
				}
			}
		}
	},
	
	choose : function () {
		var O = this.bvFormOther.bvFormOther.other;
		if (this.options[this.selectedIndex].value == 'other') {
			this.bvFormOther.style.height = 'auto';
			bv.css.removeClass(this.bvFormOther, 'bvFormOtherHide');
			bv.css.addClass(this.bvFormOther, 'bvFormOtherShow');
			this.bvFormOther.style.height = '';
			O.value = this.options[this.selectedIndex].text;
			setTimeout(function (el) { var trg = el; return function () { trg.focus(); trg.select(); }}(O), 10);
		} else {
			O.value = '';
		}
	}, // END: choose
	
	offer : function () {
		bvFormOther.accept(this);
	}, // END: offer
	
	checkAcceptance : function (e) {
		switch (e.keyCode) {
			case 38 : // cursor up
			case 40 : // cursor down
			case 27 : // escape key
			case 13 : // enter or return
				bvFormOther.accept(this);
				e.preventDefault();
				return false;
				break;
		}
	
		
	}, // END: checkAcceptance
	
	accept : function (el) {
		el.bvFormOther.style.height = 'auto';
		bv.css.removeClass(el.bvFormOther, 'bvFormOtherShow');
		bv.css.addClass(el.bvFormOther, 'bvFormOtherHide');
		el.bvFormOther.style.height = '';
		var C = el.bvFormOther.bvFormOther.chooser;
		C.options[C.selectedIndex].text = el.value;
	}, // END: accept
	
	complete : true
}

if (bv && bv.event) bv.event.add(window, "domready", bvFormOther.init);




/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/
 * bvRoll, v2.0
 * (c) 2006 bivia.com
 * created by Ben Curtis of bivia.com, February 22 2005
 * $Id: bvRoll.js,v 1.1.2.1 2006/08/13 23:46:51 bcurtis Exp $
 *~~~~*/

var bvRoll = {

	trigger :  'bvRoll',
	withOn :   'bvRoll',
	withDown : 'bvRollDown',
	sticky :   {},

	config : function (name, value) {
		if (typeof bvRoll[name] == typeof value)
			bvRoll[name] = value;
		else if (bv) bv.debug.msg('type mismatch in call to config(): '+ name +'::'+ value, 'bvRoll');
	},

	setStickyOn : function () {
		for (var idx=0; idx<arguments.length; idx++)
			bvRoll.sticky[arguments[idx]] = { "from":"off", "to":"on" };
	},
	setStickyOff : function () {
		for (var idx=0; idx<arguments.length; idx++)
			bvRoll.sticky[arguments[idx]] = { "from":"on", "to":"off" };
	},

	init : function() {
		var Imgs = document.getElementsByTagName('img');
		for (var xx=0; xx<Imgs.length; xx++) {
			if (
				Imgs[xx].className &&
				Imgs[xx].className.indexOf(bvRoll.trigger) != -1
			) { // then enable the rollover for that image
				if (Imgs[xx].className.indexOf(bvRoll.withDown) != -1)
					bvRoll.prepRollover(Imgs[xx],"off","on","down");
				else
					bvRoll.prepRollover(Imgs[xx],"off","on");
			}
		}
	},
	
	flip : function(I,Trg) {
		var To = (Trg) ? Trg :
					(I.src.indexOf('_off') +1) ? 'on' : 'off';
		if (I[To]) I.src = I[To].src;
	},
	
	preload : function(I) {
		if (!I.loaded && I.src) {
			var Args = (arguments.length > 1) ? arguments : ["null","on","off"];
			I.loaded = false;
			if (I.realSrc) { // png has been fixed via pngbehavior.htc
				var Srcs = I.realSrc.match(/^(.*?)([^\/]+)_(on|off|down)\.(\w{3,4})$/);
			} else {
				var Srcs = I.src.match(/^(.*?)([^\/]+)_(on|off|down)\.(\w{3,4})$/);
			}
			for (var xx=1; xx<Args.length; xx++) {
				I[Args[xx]] = new Image();
				I[Args[xx]].src = Srcs[1] + Srcs[2] +"_"+ Args[xx] +"."+ Srcs[4];
			}
			if (bvRoll.sticky[Srcs[2]]) {
				I[bvRoll.sticky[Srcs[2]]["from"]] = I[bvRoll.sticky[Srcs[2]]["to"]];
				bvRoll.flip(I, "off");
			}
			I.loaded = true;
		}
	},
	
	prepRollover : function (I,OffSuf,OnSuf,DownSuf) {
		if (typeof(I) != "object") return;
		var Off = (OffSuf) ? OffSuf : "off";
		var On = (OnSuf) ? OnSuf : "on";
		var Down = (DownSuf) ? DownSuf : false;
		
		if (Down) bvRoll.preload(I,Off,On,Down);
		else bvRoll.preload(I,Off,On);

		bv.event.add(I, 'mouseover', function () { bvRoll.flip(this,On); } );
		bv.event.add(I, 'mouseout',  function () { bvRoll.flip(this,Off); });
		if (Down) {
			bv.event.add(I, 'mousedown', function () { bvRoll.flip(this,Down); });
			bv.event.add(I, 'mouseup',   function () { bvRoll.flip(this,On); }  );
		}
		
	}

}
if (window.bv && bv.event) bv.event.add(window, 'domready', bvRoll.init );