//<script language="javascript">
/*=============================================================================
 WebSolvers Framework Library
 Copyright 2003, WebSolvers, Inc., All Rights Reserved.

 Library 
 Cross-Browser/Platform common library

 Revision History:
 6-26-03 Created

 Public Functions:
	cint(num)		- Casts a variable to an integer.
	cdbl(num)		- Casts a variable to a floating point.
	cnum(num)		- Casts a variable to etiher an int or float depending
						on the contents.
	writeDHTML(src)	- Writes the source HTML to the browser in a hopefully
						compatable way.
	initDHTML()		- Used to manually initialize code when auto-init does not
						work.

 Public Object:
	dhtml			- Provides basic cross/browser code base for other functions
	
=============================================================================

 The WebSolvers Framework Library may be used and/or modified by anyone owning
 the original work as it was incorporated into an original development project
 so long as this copyright notice and the comments above remain intact.

 By using this code you agree to indemnify WebSolvers, Inc. from any liability
 that might arise from its use.

 This code may not be sold exclusively or as a part of other code without prior
 written consent and is expressly forbidden.

 Obtain permission before redistributing this software over the Internet or
 in any other medium. In all cases the copyright and header must remain intact.
============================================================================= */

function cint(num) {
	var cmp = '-0123456789,';
	var cmp2 = ',';
	if(!num && num != 0)
		return NaN;
		
	if(cmp.diff(num.toString()).length)
		return NaN;
	else
		return parseInt(cmp2.diff(num.toString()), 10);
}

function cdbl(num) {
	var cmp = '-0123456789.,$';
	var cmp2 = '$,';
	var per = num.toString().indexOf('%');

	if(!num && num != 0)
		return NaN;

	if(per > -1) {
		num = num.toString().substr(0, per) + num.toString().substr(per+1);
	}
	
	if(cmp.diff(num.toString()).length)
		return NaN;
	else if(per > -1)
		return parseFloat(cmp2.diff(num.toString()))/100;
	else
		return parseFloat(cmp2.diff(num.toString()));
}

function cnum(num) {
	var cmp = ".$%";

	if(!num && num != 0)
		return NaN;

	if(cmp.diff(num.toString()).length)
		return cdbl(num);
	else
		return cint(num);
}

if (typeof((new String()).trim) == "undefined") {
	function stringObject_trim(lr) {
		var start=0; end=this.length;

		if(lr != 0)
			while((this.substring(start, start+1) == ' ') && (start < end))
				start++;
				
		if(!lr)
			while((this.substring(end-1, end) == ' ') && (end > start))
				end--;
		
		return this.substring(start, end);
	}
	
	String.prototype.trim = stringObject_trim;
	String.prototype.ltrim = function anonymous() { return this.trim(1); };
	String.prototype.rtrim = function anonymous() { return this.trim(0); };
}

if (typeof((new String()).diff) == "undefined") {
	function stringObject_DiffIn(compare, lc) {
		var diff = "";
		var cmp = this, cmp2 = compare;
		if(lc) {
			cmp = this.toLowerCase();
			cmp2 = compare.toLowerCase();
		}
	
		for(var i = 0; i < cmp2.length; i++)
			if(!lc && cmp.indexOf(cmp2.substr(i, 1)) == -1)
				diff += compare.substr(i, 1);
	
		return diff;
	}
	String.prototype.diff = stringObject_DiffIn;
}

if (typeof((new String()).toNumber) == "undefined") {
	function stringObject_ToNumber() {
		return cnum(this);
	}
	String.prototype.toNumber = stringObject_ToNumber;
}

//--- Some version of IE for the mac forgot how to push.
if (typeof((new Array()).push) == "undefined") {
 function arrayObject_Push() {
     for (var i = 0 ; i < arguments.length ; i++) {
         this[this.length] = arguments[i];
        }
    } Array.prototype.push = arrayObject_Push;
}

//--- Some version of IE for the mac forgot how to pop as well.
if (typeof((new Array()).pop) == "undefined") {
 function arrayObject_Pop() {
 		var res = this[0];
 		
 		for(var i = 1 ; i < arguments.length; i++) {
 			this[i-1] = this[i];
 		}
 		this.length--;
 		
 		return res;
    } Array.prototype.pop = arrayObject_Pop;
}

//--- indexOf is so usefull, why did they not include it?.
if (typeof((new Array()).indexOf) == "undefined") {
 function arrayObject_IndexOf(search,lc) {
		var idx = -1;
		
		for(idx = 0; idx < this.length; idx++) {
			if(lc && this[idx].toString().toLowerCase() == search.toString().toLowerCase())
				return idx;
			else if(this[idx] == search)
				return idx;
		}
		
		return -1;
    } Array.prototype.indexOf = arrayObject_IndexOf;
}

//======================================================================================
//                         Netscape 4 compatability functions
//======================================================================================
function dhtml_NN4Resize(e) {
	if(window.innerWidth != window.oInnerWidth || window.innerHeight != window.oInnerHeight)
		window.history.go(0);
		
	if(JS_OnResize)
		JS_OnResize(e);
}

var JS_OnResize = window.onresize;
if(document.layers) {
	window.oInnerWidth = window.innerWidth;
	window.oInnerHeight = window.innerHeight;
	window.onresize = dhtml_NN4Resize;
}	

//======================================================================================
//							Basic DHTML Setup and compatability
//======================================================================================

function writeDHTML(src) {
	document.open();
	if(window.dhtml)
		document.write(dhtml.process(src));
	else
		document.write(src);
	document.close();
}

function initDHTML() {
	if(!dhtml.onload && window.onload != dhtmlObject_OnLoad) {
		dhtml.onload = window.onload;
		window.onload = dhtmlObject_OnLoad;
	}
}

function debugObj(obj, nw) {
	var so = '' + obj;
	var h = '';
	if(so.substr(0, 8) == '[object ') {
		h = dhtml_debug(obj, '', 2);
	} else {
		h = obj;
	}

	if(nw)
		with(window.open()) {
			document.open();
			document.write("<pre>" + h + "</pre>");
			document.close();
		}
	else
		alert(h);
}

function dhtmlObject() {
	this.onload = window.onload;
	window.onload = dhtmlObject_OnLoad;

	this._init = 0;

	if(!document.parentWindow)
		document.parentWindow = window;

	this.rootWin = document.parentWindow.top;
	this.rootDoc = this.rootWin.document;

	if(document.all) {
		this.dhtml = true;
		this.DOM = true;
		this.IE = true;

		if(navigator.platform.indexOf("Mac") > -1)
			this.mac = true;
		else if(navigator.platform.indexOf("nix") > -1)
			this.unix = true;
		else
			this.windows = true;

		if((dhtmlIdx = navigator.appVersion.indexOf("MSIE 5.0;")) > -1) {
			this.major = 5;
			this.minor = 0;
		} else {
			this.major = 6;
			this.minor = 0;
		}

		this.build = dhtmlObject_BuildDOM;
	} else if(document.getElementById) {
		this.DOM = true;
		this.mozilla = true;
		this.W3C = true;

		if(navigator.platform.indexOf("Mac") > -1)
			this.mac = true;
		else if(navigator.platform.indexOf("nix") > -1)
			this.unix = true;
		else
			this.windows = true;

		this.major = 1;
		this.minor = 0;

		this.build = dhtmlObject_BuildDOM;
	} else if(document.layers) {
		this.dhtml = true;
		this.NN4 = true;

		if(navigator.platform.indexOf("Mac") > -1)
			this.mac = true;
		else if(navigator.platform.indexOf("nix") > -1)
			this.unix = true;
		else
			this.windows = true;

		this.major = 4;
		this.minor = 0;

		this.build = dhtmlObject_Build;
	} else if(document.images) {
		this.dhtml = true;
		this.basic = true;
		this.major = 3;
		this.minor = 0;

		this.build = dhtmlObject_Build;
	}

	this.toString = function anonymous() { return this.dhtml; };
	this.tag = new Array();
	this.basic = new Array();

	this.addTag = dhtmlObject_AddTag;
	this.addBasicInit = dhtmlObject_AddBasicInit;
	this.runBasic = dhtmlObject_RunBasic;
	this.addNormDoc = dhtmlObject_AddNormDoc;
	this.addNorm = dhtmlObject_AddNorm;
	this.process = dhtmlObject_Process;
	this.grepTags = dhtmlObject_GrepTags;
	this.grepAttributes = dhtmlObject_GrepAttributes;
	this.setType = dhtmlObject_SetType;

	this._normDoc = new Array();
	this.normDoc = dhtmlObject_NormDoc;
	this._normalize = new Array();
	this.normalize = dhtmlObject_Norm;
	this._quickNorm = null;
	this.quickNorm = dhtmlObject_QuickNorm;
	this.makeContainer = function anonymous(obj) { return obj; };
	this.procAlign = dhtmlObject_ProcAlign;
	
	this.getKeycode = dhtmlObject_GetKeycode;
}

function dhtmlObject_GetKeycode(e) {
	if(!e && event)
		e = event;

	return (e.which ? e.which : e.keyCode);
}

function dhtmlObject_OnLoad(e) {
	if(window.dhtml && !window.dhtml._init) {
		dhtml.build(document);

		dhtml._init = 1;
		if(dhtml.onload)
			dhtml.onload(e);
	}
}

function dhtmlObject_AddTag(tag, func, bfunc, prefunc, block) {
	var idx = this.tag.length;

	this.tag[idx] = new tagObject(tag, func, bfunc, prefunc, block);
}

function tagObject(tag, func, bfunc, prefunc, block) {
	this.name = tag;
	this.proc = func;
	this.basic = bfunc;
	this.init = prefunc;
	this.block = block;
}

function dhtmlObject_AddBasicInit(object, func) {
	var idx = this.basic.length;
	var param = new Array();
	var i = 0;

	for(i = 2; i < dhtmlObject_AddBasicInit.arguments.length; i++) {
		param[param.length] = dhtmlObject_AddBasicInit.arguments[i];
	}
	this.basic[idx] = new basicInitObject(object, func, param);
}

function basicInitObject(object, func, params) {
	this.object = object;
	this.func = func;
	this.params = params;
}

function dhtmlObject_Process(html) {
	var tags = null;
	var rsrc = "";
	var src = "";
	var re = null;
	var re2 = null;
	var m = null;
	var m2 = null;
	var l = 0;
	var osrc = "";
	var nsrc = "";
	var refix = 0;
	tags = new Array();

//	alert("Processing - " + html);
	if(this.dhtml) {
		var rsrc = "";
		for(var i = 0; i < this.tag.length; i++) {
			tag = this.tag[i];
			if(tag.init && !(this.DOM && tag.proc)) {
				html = dhtml.grepTags(tag.name, html, tag.block, tag.init, false);
			}
		}
	}
//	alert("Processed - " + html);

	return html;
}

function dhtmlObject_GrepTags(tag, html, block, func) {
	var src = '';
	var re = null;
	var re2 = null;
	var re3 = null;
	var m = null;
	var refix = 0;
	var attr = null;
	var args = new Array();
	var html2 = "";
	var m2 = null;
	var start = 0;
	var cut = 0;

	if(!tag.pop)
		tag = new Array(tag);
	if(!func.pop)
		func = new Array(func);

//alert("Grepping Tags - " + tag);

	if(dhtmlObject_GrepTags.arguments.length > 4)
		for(re = 5; re < dhtmlObject_GrepTags.arguments.length; re++)
			args[args.length] = dhtmlObject_GrepTags.arguments[re];

	src = '<\\s*(' + tag.join('|') + ')\\s*([^>]*)(/)?>'
	re = new RegExp(src, "i");

	m = re.exec(html);
	if(refix || !re.lastIndex && re.lastIndex != 0) {
		re.lastIndex = RegExp.lastIndex;
		refix = 1;
	}
	while(re.lastIndex > -1 && m && m.length) {
		attr = dhtml.grepAttributes(m[2]);
		if(!block || m[3] == "/")
			html = html.substr(0, re.lastIndex - m[0].length) + func[tag.indexOf(m[1], true)](attr, '', args) + html.substr(re.lastIndex);
		else if(block) {
			src = '<\\s*' + m[1] + '\\s*([^>]*)(/)?>'
			re2 = new RegExp(src, "i");
			src = '<\\s*/\\s*' + m[1] + '\\s*>';
			re3 = new RegExp(src, "i");

			start = re.lastIndex;
			cut = 0;
			html2 = html.substr(start);
			re2.exec(html2);
			if(refix)
				re2.lastIndex = RegExp.lastIndex;
			m2 = re3.exec(html2);
			if(refix)
				re3.lastIndex = RegExp.lastIndex;
			while(re2.lastIndex > 0 && re2.lastIndex < re3.lastIndex) {
				cut += re3.lastIndex;
				html2 = html.substr(cut);
				re2.exec(html2);
				if(refix)
					re2.lastIndex = RegExp.lastIndex;
				m2 = re3.exec(html2);
				if(refix)
					re3.lastIndex = RegExp.lastIndex;
			}
			if(m2)
				cut += re3.lastIndex - m2[0].length;
			html2 = html.substr(start, cut);
			if(m2)
				cut += m2[0].length;
			html = html.substr(0, start - m[0].length) + func[tag.indexOf(m[1], true)](attr, html2, args) + html.substr(start + cut);
		}
		m = re.exec(html);
		if(refix)
			re.lastIndex = RegExp.lastIndex;
	}

//alert("Done Grepping Tags - " + tag);

	return html;
}

function dhtmlObject_GrepAttributes(html) {
	var re = /(\w+)\s*=\s*('([^']+)'|"([^"]+)"|([^'"\s]+))/;
	var m = re.exec(html);
	var attr = new Array();
	var refix = 0;

//alert("Grepping Attributes - " + html);
	
	if(refix || !re.lastIndex && re.lastIndex != 0) {
		re.lastIndex = RegExp.lastIndex;
		refix = 1;
	}
	while(re.lastIndex > -1 && m && m.length) {
		if(m[2].length && m[3].length)
			attr[attr.length] = new Array(m[0], m[1], m[3]);
		else if(m[2].length && m[4].length)
			attr[attr.length] = new Array(m[0], m[1], m[4]);
		else if(m[2].length && m[5].length)
			attr[attr.length] = new Array(m[0], m[1], m[5]);

		html = html.substr(0, re.lastIndex - m[0].length) + html.substr(re.lastIndex);

		m = re.exec(html);
		if(refix)
			re.lastIndex = RegExp.lastIndex;
	}

//alert("Done Grepping Attributes");

	return attr;		
}

function dhtmlObject_SetType(elem, init) {
	var i = 0;
	var cmd = "";
	elem._dhtmlInit = init;
	if(dhtmlObject_SetType.arguments.length > 2) {
		for(i = 2; i < dhtmlObject_SetType.arguments.length; i++)
			cmd += ", dhtmlObject_SetType.arguments["+i+"]";
		cmd = "elem._dhtmlInit(" + cmd.substr(1) + ");"; 
		eval(cmd);
	} else
		elem._dhtmlInit();
}

function dhtmlObject_Build(doc) {
	var i = 0;
	var layer = null;
	var tag = null;
	var basic = null;

	this.normDoc(doc);

	if(this.NN4) {
		for(i = 0; i < doc.layers.length; i++) {
			layer = this.quickNorm(doc.layers[i], doc);
			layer._layer = true;
			this.normDoc(layer.document);
			this.build(layer.document);
		}
	}

	this.runBasic(doc);

	for(i = 0; i < this.tag.length; i++) {
		tag = this.tag[i];
		if(tag.basic)
			tag.basic(doc);
	}
}

function dhtmlObject_RunBasic(doc) {
	var document = doc;
	var i = 0;
	var j = 0;
	var cmd = "";
	var elem = null;
	
	for(i = 0; i < this.basic.length; i++) {
		basic = this.basic[i];

		if(basic.object && basic.func) {
			eval("elem = " + basic.object + ";");
			if(elem) {
				cmd = "";
				for(j = 0; j < basic.params.length; j++) {
					if(basic.params[j] && basic.params[j].toString().indexOf('[eval]') == 0)
						eval("basic.params['" + j + "'] = " + basic.params[j].substr(6) + ";");
					cmd += ", basic.params["+j+"]";
				}
				cmd = "dhtml.setType(elem, " + basic.func + cmd + ");";
				eval(cmd);
			}
		}
	}
	
}

function dhtmlObject_BuildDOM(doc) {
	var i = 0, j = 0;
	var tag = null;
	var node = null;
	var elem = null;
	var cont = null;

	this.normDoc(doc);

	for(i = 0; i < this.tag.length; i++) {
		tag = this.tag[i];

		if(tag.proc) {
			node = doc.getElementsByTagName(tag.name);

			for(j = 0; j < node.length; j++) {
				cont = null;
				elem = this.normalize(node[j], doc);
				if(tag.block > 0)
					cont = this.makeContainer(elem);

				if(cont && cont != elem) {
					j--;
					elem = cont;
				}

				tag.proc(elem, doc);
			}
		} else if(tag.basic)
			tag.basic(doc);
	}

	this.runBasic(doc);
}

function dhtmlObject_AddNormDoc(func) {
	if(!func)
		return;
		
	this._normDoc[this._normDoc.length] = func;
}

function dhtmlObject_NormDoc(doc) {
	var i;
	
	if(!doc)
		return null;

	if(!dhtml)
		return doc;

	if(doc._dhtmlNorm)
		return doc;

	doc.root = this.rootDoc;
	
	for(i = 0; i < this._normDoc.length; i++)
		this._normDoc[i](doc);
		
	doc._dhtmlNorm = 1;
	return doc;
}

function dhtmlObject_AddNorm(func) {
	if(!func)
		return;
		
	this._normalize[this._normalize.length] = func;
}

function dhtmlObject_Norm(elem, doc) {
	var i;
	
	if(!elem)
		return null;

	if(elem._dhtmlNorm)
		return elem;

	if(!doc)
		doc = this.rootDoc;

	if(elem._layer)
		elem.nodeType = 1;

	if(!elem.document)
		elem.document = doc;
	else
		this.normDoc(elem.document);
		
	for(i = 0; i < this._normalize.length; i++)
		this._normalize[i](elem);
	
	elem._dhtmlNorm = 1;
	return elem;
}

function dhtmlObject_QuickNorm(elem, doc) {
	var i;
	
	if(!elem)
		return null;

	if(elem._dhtmlNorm || elem._qdhtmlNorm)
		return elem;

	if(!doc)
		doc = this.rootDoc;

	if(elem._layer)
		elem.nodeType = 1;

	if(!elem.document)
		elem.document = doc;
	else
		this.normDoc(elem.document);
		
	if(this._quickNorm)
		this._quickNorm(elem, doc);
	
	elem._qdhtmlNorm = 1;
	return elem;
}

function dhtmlObject_ProcAlign(align) {
	var i = parseInt(align);

	if(isNaN(i)) {
		i = -1;
		if(align && align.length) {
			switch(align.substring(0, 1).toLowerCase()) {
			case "c":
			case "m":
				i = 0;
				break;
			case "r":
			case "b":
			case "d":
			case "v":
				i = 1;
				break;
			}
		}
	} else if(i < -1)
		i = -1;
	else if (i > 1)
		i = 1;

	return i;
}

//======================================================================================
//                                Initialization code
//======================================================================================
var dhtmlShared = "";
var dhtml = new dhtmlObject();