/* -----------------------------------------------------------------------------------------------
	DanUts.js
	Revision History
	----------------
	
	*** NOTE addDiag depends ob isDev being set ***

	05-Nov-04 v07
		Created

	20-May-05
		Added primitive set functions
		
	09-Aug-05
		Edits for cross-browser compatibility
		
	03-Sep-05
		Added Get/SetAtt(ribute) - replace all instances in this unit with reference to new functions
		Previous in (local) DanUts01.js.old
		
	11-Sep-05
		Add Get/SetElText

------------------------------------------------------------------------------------------------- */

/*
function BrowserCheck() {
var b = navigator.appName;
if (b == "Netscape") this.b = "NS";
else if (b == "Microsoft Internet Explorer") this.b = "IE";
else this.b = b;
this.v = parseInt(navigator.appVersion);
this.NS = (this.b == "NS" && this.v>=4);
this.NS4 = (this.b == "NS" && this.v == 4);
this.NS5 = (this.b == "NS" && this.v == 5);
this.IE = (this.b == "IE" && this.v>=4);
this.IE4 = (navigator.userAgent.indexOf('MSIE 4')>0);
this.IE5 = (navigator.userAgent.indexOf('MSIE 5')>0);
if (this.IE5 || this.NS5) this.VER5 = true;
if (this.IE4 || this.NS4) this.VER4 = true;
this.OLD = (! this.VER5 && ! this.VER4) ? true : false;
this.min = (this.NS||this.IE);
}
var _browserObj = new BrowserCheck();
var isIE = _browserObj.IE;
var isNS = _browserObj.NS;
var browserId = (isIE ? "IE" : (isNS ? "NS" : "??"));
*/

// -----------------------------------------------------------------------------------------------------  sameText()
function sameText(s1, s2) {
	// need to add prototpye method to String type!!!
	if (s1 && s2) {
		return (s1.toLowerCase() == s2.toLowerCase())
	}
	else
	  return false;
} //sameText

// -------------------------------------------------------------------------------------------------  containsText()
function containsText(AText, ASubText) {
	// need to add prototpye method to String type!!!
	if (AText && ASubText) {
		AText = AText.toLowerCase();
		return (AText.indexOf(ASubText.toLowerCase()) >= 0)
	}
	else
	  return false;
} // containsText

// -----------------------------------------------------------------------------------------------------  padZero()
function padZero(s, w) {
	s = String(s);
	while (s.length < w)
		s = '0' + s;
	return s;
}

function commaSepInt (n) {
	var s = n.toString();
	var sOut = "";
	var l = s.length;
	for (var i = 0; i < l; i++) {
		if (((i % 3)==0) && (i!=0))// && (i!=(l-1)))
			sOut = ',' + sOut;
		sOut = s.charAt(l-i-1) + sOut;
	}
	return sOut;
}

function hex (n) {
	// returns two-digit upper case hex
	sOut = n.toString(16);
	sOut = sOut.toUpperCase();
	sOut = padZero(sOut,2);
	return sOut;
} // hex

function makeGetFormat (s) {
	// converts string s to format suitable for GET form submit
	var sOut = "";
	var c;
	var n;
	var l = s.length;
	for (var i = 0; i < l; i++) {
		c = s.charAt(i);
		if (c>='0' && c<='9' || c>='A' && c<='Z' || c>='a' && c<='z')
			sOut += c;
		else if (c == ' ')
			sOut += '+';
		else {
			n = c.charCodeAt(0);
			n = n & 255;
		  sOut += '%' + hex(n);
		}
	} // for
	return sOut;
} // makeGetFormat

function getScriptName() {
	// returns name of current script
	var s = document.location.pathname;
	var p = Math.max(s.lastIndexOf('/'),s.lastIndexOf('\\'));
	if (s != '/')
		s = s.slice(p+1);
	return s;
}

// return rule style for style sheet with selectorText rNam from style sheet id ssNam
// we can then do, e.g., getStyleSheetRule ("style1", ".menItem").width = "150px"
function getStyleSheetRule (ssNam, rNam) {
	var ss = document.styleSheets[ssNam];
	if (ss) {
		for (i = 0; i < ss.rules.length; i++) {
			if (ss.rules[i].selectorText == rNam)
				return  ss.rules[i].style
		}
	}
}

// --------------------------------------------------------------------------------------------------------  getEl()
function getEl (elName, parent) {
	// getElementById within parent, or document if null
	// return ((parent) ? parent : document).getElementById(elName);
	return ((parent) ? parent : document).getElementById(elName);
} // getEl

// --------------------------------------------------------------------------------------------------------  getAtt()
function getAtt (el, attName) {
	if (typeof(el)=="string")
		el = getEl (el);
	/* */
	if (el)
		return el[attName];
	/* */
	/* * / 
	if (el)
		return el.getAttribute (attName);
	/* */
	else
		return null;
} // getAtt

// --------------------------------------------------------------------------------------------------------  setAtt()
function setAtt (el, attName, attVal) {
	if (typeof(el)=="string")
		el = getEl(el);
	if (el)
		/* */
		el[attName] = attVal;
		/* * /
		el.setAttribute(attName, attVal)
		/* */
} // setAtt

// --------------------------------------------------------------------------------------------------------  getEl()
// deprecated - use getElText
function getElVal (el) {
	var retVal = '';
	if (typeof(el)=="string")
		el = getEl (el);
	if (el)
		retVal = el.innerText; // NOT value
	return retVal;
} // getElVal

// --------------------------------------------------------------------------------------------------------  setEl()
// deprecated - use setElHTML
function setEl (elName, AinnerHTML) {
	var el = getEl(elName);
	if (el)
		el.innerHTML = AinnerHTML;
} // setEl

// ----------------------------------------------------------------------------------------------------  getElHTML()
function getElHTML (el ) {
	if (typeof(el)=="string")
		el = getEl (el);
	if (el)
		return el.innerHTML;
	else
		return "el is not an object";
} // getElHTML

// ----------------------------------------------------------------------------------------------------  setElHTML()
function setElHTML (el, AinnerHTML) {
	if (typeof(el)=="string")
		el = getEl (el);
	if (el)
		el.innerHTML = AinnerHTML;
} // setElHTML

// ----------------------------------------------------------------------------------------------------  getElText()
function getElText (el ) {
	if (typeof(el)=="string")
		el = getEl (el);
	if (el)
		return el.innerText;
	else
		return "el is not an object";
} // getElText

// ----------------------------------------------------------------------------------------------------  setElText()
function setElText (el, AinnerText) {
	if (typeof(el)=="string")
		el = getEl (el);
	if (el)
		el.innerText = AinnerText;
} // setElText

// -----------------------------------------------------------------------------------------------------  createEl()
function createEl (elType) {
	// createElement of type elType
	return document.createElement(elType);
}

// ---------------------------------------------------------------------------------------------------------- dispEl
// display element el if exp==1, else hide
function dispEl (el, exp, doInline) {
	if (typeof(el)=="string")
		el = getEl (el);
	if (el)
		if (doInline) {		// visibility
			if (exp==1) {
				el.style.display = "inline";
			}
			else
				el.style.display = "none"
		}
		else {					// display
			if (exp==1) {
				el.style.display = "block";
				el.visibility = "visible";
			}
			else if (exp==-1)
				el.visibility = "hidden"
			else 
				el.style.display = "none"
		}
}

// ---------------------------------------------------------------------------------------------------------- setFormVal
// set form value element el to value val
function setFormVal (_el, _val, _globVar) {
	if (typeof(_el)=="string")
		_el = getEl (_el);
	if (_el)
		_el.value = _val;
	/* Not that easy!
	if (_globVar) {			// create function to assign global
		addDiag ('diag00' ,'creating function');
		if (typeof(_el)=="string") {
			//var f = new Function (_globVar + " = '" + _val + "'");
			var s = "_globVar = '" + _val + "';";
			var f = new Function ("addDiag ('diag00', " + s + ");");		
		}
		else {
			 // s = "_globVar = " + _val + ";";
			//s = "addDiag ('diag00', " + s + ");";
			var f = new Function (
								"_globVar",
// OK								"_val", "addDiag ('diag00', \"addDiag ('diag00', \" + _globVar + \" = \" + _val + \";\" + \");\")");		
								"_val", "_globVar + \" = \" + _val + \";\"");
			
			//var f = new Function (_globVar + " = " + _val);		
		}
		f(_globVar, _val);
	}
	*/
} // setFormVal

// ---------------------------------------------------------------------------------------------------------- getFormVal
// get form value element el from
function getFormVal (el) {
	var retVal = '';
	if (typeof(el)=="string")
		el = getEl (el);
	if (el)
		retVal = el.value; // NOT value
	return retVal;
} // getFormVal

// ---------------------------------------------------------------------------------------------  getPageEventCoords
function getPageEventCoords(evt) {
	var coords = {left:0, top:0};
	if (evt.pageX) {
  	coords.left = evt.pageX;
  	coords.top = evt.pageY;
	} else if (evt.clientX) {
  	coords.left = evt.clientX + document.body.scrollLeft - document.body.clientLeft;
   	coords.top = evt.clientY + document.body.scrollTop - document.body.clientTop;
  	// include html element space, if applicable
   	if (document.body.parentElement && document.body.parentElement.clientLeft) {
     	var bodParent = document.body.parentElement;
     	coords.left += bodParent.scrollLeft - bodParent.clientLeft;
     	coords.top += bodParent.scrollTop - bodParent.clientTop;
   	}
 	}
    	return coords;
} // getPageEventCoords

// -------------------------------------------------------------------------------------------------------  addDebug
function addDebug(S, N, el) {
	// addDiag ("diagBox", S); return; 
  if (!el)
  	el = addDebug.defEl;
  if (el==null)
  	return;
  if (N && (debugNos > '') && (debugNos.indexOf(','+N+',')==-1))
  	return;
	var o = createEl("div");
	o.innerText = S;
	el.appendChild(o);
}

function debug(A, nl) {
	// expects debug window "debug"
	if (!isDev)
		return;
	if (nl)
		A += "<br>";
	setElHTML ("debug", getElHTML("debug") + A);
}

// Returns argument with 'px' appended ------------------------------------------------------------------------  pix
function pix(N) {
	return N + 'px';
}
// Returns unique identifier qn( q1, q2 etc), starting with q1 -----------------------------------------------  unId
unId.N = 0;  // Initialise with 0
function unId() {
	return 'q' + ++unId.N
}
// Returns TRUE if el contains style nam ------------------------------------------------------------  containsStyle
function containsStyle(el, nam) {
	if (typeof(el)=="string")
		el = getEl (el);
	if (el) {
		var s = getAtt(el, "className");
		if (s==nam)
			return true
		else if (s.indexOf(nam+" ") >= 0)
			return true
		else if (s.indexOf(" "+nam) >= 0)
			return true
		else
			return false
	}
	else
		return false
}
// Add style to item class name --------------------------------------------------------------------------  addStyle
function addStyle(el, nam) {
	addDebug ('++++++++++++++++++', 6);
	addDebug ('addStyle: "' + nam + '" to "' + el+'"', 6);
	if (typeof(el)=="string")
		el = getEl (el);
	if (el) {
		addDebug ('---- addStyle: "' + nam + '" to "' + el + ' class: ' + getAtt(el,'className')+'" in "' + el + '"', 6);
		if (!containsStyle(el, nam)) {
			setAtt(el,"className", getAtt(el,"className") + " " + nam);
			addDebug ('---- Style now "' + getAtt(el,'className')+'"', 6);
		}
		else
			addDebug ('---- Style already there', 6);
	}
}
// Remove style from item class name ------------------------------------------------------------------  removeStyle
function removeStyle(el, nam) {
	addDebug ('++++++++++++++++++', 6);
	addDebug ('removeStyle: "' + nam + '" from "' + el+'"', 6);
	if (typeof(el)=="string")
		el = getEl (el);
	if (!el)
		return;
	addDebug ('---- removeStyle: "' + nam + '" from "' + getAtt(el,'className')+'" in "' + el + '"', 6);
	var s = getAtt(el,"className");
	var sa = s.split(" ");
	s = '';
	for (var i = 0; i < sa.length; i++) {
		if ((sa[i] != "") && (sa[i] != nam)) 
			s += sa[i] + " ";
	}
	s = s.substr (0, s.length-1);
	setAtt(el,"className", s);
	addDebug ('---- Style now "' + getAtt(el,'className')+'"', 6);
}
// Replace style in item class name ------------------------------------------------------------------  replaceStyle
function replaceStyle(el, namFrom, namTo) {
	addDebug ('++++++++++++++++++', 6);
	// addDiag ("diagBox", 'ReplaceStyle "' + namFrom + '" with "' + namTo + '" in "' + el + '"', 6);
	if (typeof(el)=="string")
		el = getEl (el);
	if (!el)
		return;
	if (containsStyle(el, namFrom) && !containsStyle(el, namTo)) {
		var s = getAtt(el,"className");
		addDebug ('---- removeStyle: "' + namFrom + '" from "' + getAtt(el,'className')+'"', 6);
		var sa = s.split(" ");
		s = '';
		for (var i = 0; i < sa.length; i++) {
			if ((sa[i] != "") && (sa[i] != namFrom)) 
				s += sa[i] + " ";
		}
		s += namTo;
		addDebug ('---- addStyle: "' + namTo + '"', 6);
		setAtt(el,"className", s);
		addDebug ('---- Style now "' + getAtt(el,'className')+'"', 6);
	}
	else 
		addDebug ('---- Style already exists');
}

// Returns TRUE if el contains Id nam ------------------------------------------------------------  containsId
function containsId(el, nam) {
	if (typeof(el)=="string")
		el = getEl (el);
	if (el) {
		var s = getAtt(el,"className");
		if (s==nam)
			return true
		else if (s.indexOf(nam+" ") >= 0)
			return true
		else if (s.indexOf(" "+nam) >= 0)
			return true
		else
			return false
	}
	else
		return false
}
// Add Id to item class name --------------------------------------------------------------------------  addId
function addId(el, nam) {
	addDebug ('++++++++++++++++++', 6);
	addDebug ('addId: "' + nam + '" to "' + el+'"', 6);
	if (typeof(el)=="string")
		el = getEl (el);
	if (el) {
		addDebug ('---- addId: "' + nam + '" to "' + el + ' class: ' + getAtt(el,'className')+'" in "' + el + '"', 6);
		if (!containsId(el, nam)) {
			setAtt(el,"className", getAtt(el,"className") + " " + nam);
			addDebug ('---- Id now "' + getAtt(el,'className')+'"', 6);
		}
		else
			addDebug ('---- Id already there', 6);
	}
}
// Remove Id from item class name ------------------------------------------------------------------  removeId
function removeId(el, nam) {
	addDebug ('++++++++++++++++++', 6);
	addDebug ('removeId: "' + nam + '" from "' + el+'"', 6);
	if (typeof(el)=="string")
		el = getEl (el);
	if (!el)
		return;
	addDebug ('---- removeId: "' + nam + '" from "' + getAtt(el,'className')+'" in "' + el + '"', 6);
	var s = getAtt(el,"className");
	var sa = s.split(" ");
	s = '';
	for (var i = 0; i < sa.length; i++) {
		if ((sa[i] != "") && (sa[i] != nam)) 
			s += sa[i] + " ";
	}
	s = s.substr (0, s.length-1);
	setAtt(el,"className", s);
	addDebug ('---- Id now "' + getAtt(el,'className')+'"', 6);
}
// Replace Id in item class name ------------------------------------------------------------------  replaceId
function replaceId(el, namFrom, namTo) {
	addDebug ('++++++++++++++++++', 6);
	addDebug ('ReplaceId "' + namFrom + '" with "' + namTo + '" in "' + el + '"', 6);
	if (typeof(el)=="string")
		el = getEl (el);
	if (!el)
		return;
	if (containsId(el, namFrom) && !containsId(el, namTo)) {
		var s = getAtt(el,"className");
		addDebug ('---- removeId: "' + namFrom + '" from "' + getAtt(el,'className')+'"', 6);
		var sa = s.split(" ");
		s = '';
		for (var i = 0; i < sa.length; i++) {
			if ((sa[i] != "") && (sa[i] != namFrom)) 
				s += sa[i] + " ";
		}
		s += namTo;
		addDebug ('---- addId: "' + namTo + '"', 6);
		setAtt(el,"className", s);
		addDebug ('---- Id now "' + getAtt(el,'className')+'"', 6);
	}
	else 
		addDebug ('---- Id already exists');
}

/* primitive set functions */
	function newSet() {
		return ',';
	}	// newSet
	
	function inSet (S, N) {
		// returns true if N in set
		return (S.indexOf(','+String(N)+',') >= 0)
	} // inSet
	
	function inSetP (S, N) {
		// returns position of N in set, inc leading comma, else 0
		return S.indexOf(','+String(N)+',')
	} // inSetP
	
	function addSet (S, N) {
		// Adds N to set S - returns new
		if (inSet (S, N))
			return S										// already there - return original
		else
			return S + String(N) + ',';
	} // addSet
	
	function delSet (S, N) {
		// removes N from if there set - returns new
		var S1 = ','+String(N)+',';
		var P = S.indexOf(S1);
		if (P >= 0)
			return S.substr(0, P+1) + S.substr(P+S1.length)
		else
			return S
	} // delSet
	
	function nInSet (S) {
		var N = -1;
		for (var i = 0; i < S.length; i++)
			if (S.charAt(i)==',')
				N++;
		return N
	} // nInSet
	
	function addDiag (el, line) {
		// add a line to diag element el
		if (isDev) {
			if (typeof(el)=="string")
				el = getEl (el);
			if (el)
				el.innerHTML = el.innerHTML + line + "<br>";
		} // isDev
	}

	function showOrHideDiagFields () {
		// show or hide diag fields, depending on isDevInt
		var el;				// for displaying element, or not
		var f;				// form
		for (var i = 0; i < document.forms.length; i++) {						// for all forms
			f = document.forms[i];
			for (var j = 0; j < f.length; j++) {
				el = f.elements[j];
				if (containsStyle (el, "diagField"))  {
					if (isDev)
						dispEl (el, 1);
					else	
						dispEl (el, 0);
				} // if contains
			} // for j
		} // for i
	} // showOrHideDiagFields

	function replacePage (frame, url) {
		// replace current page with url, using frame
		window.frames[frame].window.location.replace (url);
	} // replacePage
	
	function trim (s) {
		while ((s.length > 0) && (s.charAt(0) <= ' '))
			s = s.substr(1);
		while ((s.length > 0) && (s.charAt(s.length-1) <= ' '))
			s = s.substr(0, s.length-1);
		return s;
	}
	
	function copyForm (f1, f2) {
		// Copy corresponding elements from form1 to form2
		if (!(f1 && f2))
			return;

		var els1 = f1.elements;
		var els2 = f2.elements;
		var nam;
	
		for (var i = 0; i < els1.length; i++) {						// for all forms
			nam = els1[i].name;
			for (var j = 0; j < els2.length; j++)
				if (els2[j].name == nam) {
					els2[j].value = els1[i].value;
					if (els1[i].checked)
						els2[j].checked = true;
					break;
				} // for j				
		} // for i
	} // copyForm
	
	function disableFormElements (f, disable, exceptEls) {
		// set disable or enable elements for form f, apart from exceptEls
		if (typeof(f)=="string")
			f = getEl(f);
		var els = f.elements;
		var e;
		var i, j;
		var doIt;
		for (i = 0; i < els.length; i++) {
			e = els[i];
			doIt = true;
			if (exceptEls) {
				for (j = 0; j < exceptEls.length; j++)
					if (e.name == exceptEls[j]) {
						doIt = false;
						break;
					} // if
			} // if
			if (doIt)
				e.disabled = disable;
		}
	} // disableFormElements
	
	function readonlyFormElements (f, readonly, exceptEls) {
		// set readonly or enable elements for form f, apart from exceptEls
		// DOESNT WORK YET
		if (typeof(f)=="string")
			f = getEl(f);
		var els = f.elements;
		var e;
		var i, j;
		var doIt;
		for (i = 0; i < els.length; i++) {
			e = els[i];
			doIt = true;
			if (exceptEls) {
				for (j = 0; j < exceptEls.length; j++)
					if (e.name == exceptEls[j]) {
						doIt = false;
						break;
					} // if
			} // if
			if (doIt)
				e.readOnly = readonly;	// careful - attribute and property have different caps
		}
	} // readonlyFormElements
	
	function getPageName(defNam) {
		// get current page name (no suffix) from URL.
		// default to "home" if none found
		var nam = document.URL;
		var p = nam.indexOf('.php');	// try php and htm
		if (p < 0)
			p = nam.indexOf('.htm');
		if (p < 0) {
			if (defNam)
				nam = defNam;
			else
				nam = 'home';								// neither - use "home"
		}
		if (p >= 0) {
			nam = nam.substr(0, p);
			p = nam.lastIndexOf('\\');
			var p1 = nam.lastIndexOf('/');
			if (p1 > p)
				p = p1;
			nam = nam.substr(p+1);
		}
		return nam;
	} // getPageName