/* ===================================================================================

	TITLE:			Common Fnctions
	DESCRIPTION:	Client script functions which mimics similar functions and methods 
					found in VBA/VBScript.
	FILENAME:		common.js

	AUTHOR:			Randy Maloney
	CREATED:		27 May 2002

	VERSION:		1.0		27 May 2002		Created

	----------------------------------------------------------------------------------
	HISTORY:

	23 Feb 1999		[randym]	Inital script file created.
	04 Jan 2000		[randym]	Upadate to take advantage of JavaScript 1.2.
	24 Oct 2000		[randym]	Bug Fix: inString() now returns null and not zero if 
								string is not found.
								New Method: getAttrib()

	----------------------------------------------------------------------------------
	NOTES:

   =================================================================================== */

/* -- Commom Script --------------------------------------------------------- START -- */

/* -- isleapYear() -------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function isleapYear(lngYear) {
	InitLeapYear = 1880;	// Initial/base (leap) year to start from.
	var blnIsSafe = false;
	var lngSpan = 0;
	var lngCount;

		lngSpan = lngYear - InitLeapYear;

		for (lngCount = 0; lngCount < lngSpan + 4; lngCount = lngCount + 4) {
			if (lngSpan == lngCount) {
				blnIsSafe = true;
				break
			} else {
				blnIsSafe = false;
			}
		}

		return(blnIsSafe);
	}

/* -- MonthName() --------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function MonthName(lngNumber) {

		if (isNaN(lngNumber) != true) {
			lngNumber = parseInt(lngNumber);

			if (isNaN(lngNumber)) {
				return(void 0);
			}
		}

		switch (lngNumber) {
			case 1:
				return("January");
				break
			case 2:
				return("February");
				break
			case 3:
				return("March");
				break
			case 4:
				return("April");
				break
			case 5:
				return("May");
				break
			case 6:
				return("June");
				break
			case 7:
				return("July");
				break
			case 8:
				return("August");
				break
			case 9:
				return("September");
				break
			case 10:
				return("October");
				break
			case 11:
				return("November");
				break
			case 12:
				return("December");
				break
		}
	}

/* -- strInVar() ---------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function strInVar(vChar, except) {
	var astrException;
	var blnIsSafe = false;
	var Count, Count2;
	var intLength = vChar.length;

		if (typeof(except) != "undefined") astrException = splitt(except, null);

		for (Count = 0; Count < intLength; Count++) {
			// Character code ranges between 65 to 90 (A - Z) and 97 to 122 (a - z)
			if (vChar.charCodeAt(Count) >= 65 && vChar.charCodeAt(Count) <= 90 || 
				vChar.charCodeAt(Count) >= 97 && vChar.charCodeAt(Count) <= 122) 
			{
				if (typeof(except) != "undefined") {
					for (Count2 = 0; Count2 <= astrException.length - 1; Count2++) {
						if (vChar.substring(Count, Count + 1) == astrException[Count2]) {
							blnIsSafe = false;
							break
						} else {
							blnIsSafe = true;
						}
					}
				} else {
					blnIsSafe = true;
				}
			}
		}

		return(blnIsSafe);
	}

/* -- isNumber() ---------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function isNumber(vntChar) {
	var blnIsSafe = true;
	var Count;
	var intLength = vntChar.length;

		for (Count = 0; Count < intLength; Count++) {
			/*
				Numeric character code range 48 to 57 (0 - 9).
				Loop though string to find any cahracters outside this range.				
			*/
			if (vntChar.charCodeAt(Count) <= 48 && 
				vntChar.charCodeAt(Count) >= 57 &&
				vntChar.charCodeAt(Count) != 46) {		// exclude for decimal values.
				return(false);
			}
		}

		return(blnIsSafe);
	}

/* -- inString() ---------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function inString() {
	var intCount, intStart, intSrcLength;
	var strSource, strSearch;

		if (arguments.length == 2) {
			// default the start marker from zero.
			intStart = 0;
			strSource = arguments[0];
			strSearch = arguments[1];

			intSrcLength = arguments[0].length
		} else {
			intStart = arguments[0];
			strSource = arguments[1];
			strSearch = arguments[2];

			intSrcLength = arguments[1].length;
		}

		if (strSource == null || strSearch == null) {
			return(null);
		} else if (strSource.length == 0) {
			return(0);
		} else if (intStart > strSource.length) {
			return(0);
		}

		for (intCount = intStart; intCount <= (intSrcLength - strSearch.length); intCount++) {
			if (strSource.substring(intCount, intCount + strSearch.length) == strSearch) {
				// Return the position found within the variable.
				return(intCount);
			}
		}

		// None found
		return(null);
	}

/* -- spcInVar() ---------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function spcInVar(value) {
	var blnIsSafe = false;
	var Count;

		for (Count = 0; Count < value.length; Count++) {
			if (value.charCodeAt(Count) == 32) {
				blnIsSafe = true;
				break
			}
		}

		return(blnIsSafe);
	}

/* -- sblInVar() ---------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function sblInVar(vChar, except) {
	var astrException;
	var blnIsSafe = false;
	var Count, Count2;
	var intLength = vChar.length;

		if (typeof(except) != "undefined") astrException = splitt(except, null);

		for (Count = 0; Count < intLength; Count++) {
			// Character code ranges outside of 65 to 90 (A - Z) and 97 to 122 (a - z)
			if (!strInVar(vChar.substring(Count, Count + 1)) && !numInVar(vChar.substring(Count, Count + 1))) {
				if (typeof(except) != "undefined") {
					for (Count2 = 0; Count2 <= astrException.length - 1; Count2++) {
						if (vChar.substring(Count, Count + 1) == astrException[Count2]) {
							blnIsSafe = false;
							break
						} else {
							blnIsSafe = true;
						}
					}
				} else {
					blnIsSafe = true;
				}
			}
		}

		return(blnIsSafe);
	}

/* -- AtInStr() ----------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function AtInStr(vChar) {
	var blnIsSafe;
	var intLength = vChar.length;
	var Count;

		for (Count = 0; Count < intLength; Count++) {
			if (vChar.charCodeAt(Count) == 64) {
				return(true);
			} else {
				blnIsSafe = false;
			}
		}

		return(blnIsSafe);
	}

/* -- getOrder() ---------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function getOrder(lngNumber) {
	var strPosition = "";

		switch (lngNumber) {
			case 1:
				strPosition += lngNumber + 'st';
				break
			case 2:
				strPosition += lngNumber + 'nd';
				break
			case 3:
				strPosition += lngNumber + 'rd';
				break
			default:
				strPosition += lngNumber + 'th';
		}

		return(strPosition);
	}

/* -- _TrimLeft() --------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function _TrimLeft(source, target) {
	var Count = 0;
	var strTrim;
	var retVal;

		if (source.length < 2) {
			return(source);
		} else if (target.length > 1) {
			return(target);
		} else if (left(source, 1) != target) {
			return(source);
		}

		// Trim the left side of string
		while (source.substring(Count, Count + 1) == target || Count == source.length) {
			Count = Count + 1
		}

		return(source.substring(Count, source.length));
	}

/* -- _TrimRight() -------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function _TrimRight(source, target) {
	var Count;
	var clone;

		if (source.length < 2) {
			return(source);
		} else if (target.length > 1) {
			return(target);
		} else if (right(source, 1) != target) {
			return(source);
		}

		// Trim the right side of string
		for (Count = source.length; Count > 0; Count--) {
			if (source.substring(Count, Count - 1) == target) {
				clone = source.substring(0, Count - 1);
			} else {
				break
			}
		}

		return(clone);
	}

/* -- _TrimOut() ---------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function _TrimOut(source, target) {
	var Count1, Count2;
	var CharCount = 0;
	var clone;
	var imageStr;

		if (source.length < 2) {
			return(source);
		} else if (target.length > 1) {
			return(target);
		}

		if (left(source, 1) == target) {
			// Trim the left side of string
			for (Count1 = 0; Count1 < source.length; Count1++) {
				if (source.substring(Count1, Count1 + 1) == target) {
					clone = right(source, source.length - (Count1 + 1));
				} else {
					break
				}
			}
		} else {
			clone = source;
		}

		if (right(clone, 1) == target) {
			// Trim the right side of string
			for (Count2 = clone.length; Count2 > 0; Count2--) {
				if (clone.substring(Count2, Count2 - 1) == target) {
					clone = left(clone, Count2 - 1);
				} else {
					break
				}
			}
		}

		return(clone);
	}

/* -- splitt() -----------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function splitt(source, delimeter) {
	var astrSplitt = new Array();
	var blnIsEnd;
	var lngCount, lngArrayCount = 0;
	var lngMarker = 0;

		for (lngCount = 0; lngCount < source.length + 1; lngCount++) {
			if (delimeter == null) {
				astrSplitt[lngCount - 1] = source.substring(lngCount, lngCount - 1);
			} else if (source.substring(lngCount, lngCount + 1) == delimeter || lngCount == source.length) {
				astrSplitt[lngArrayCount] = trim.left(source.substring(lngMarker, lngCount), " ");
				lngMarker = lngCount + 1;
				lngArrayCount++;
			}
		}

		return(astrSplitt);
	}

/* -- strip() ------------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function strip(source, delimeter) {
	var Count;
	var startMark = 0, endMark = source.length;
	var imageStr = new String();

		if (delimeter == null || delimeter.length == 0) {
			return(source);
		} else {
			Count = startMark;

			while(Count < endMark) {
				if (source.substring(Count, Count + delimeter.length) == delimeter) {
					imageStr += source.substring(startMark, Count);
					Count = Count + delimeter.length;
					startMark = Count;
				} else {
					Count++;
				}
			}

			if (startMark < endMark) {
				imageStr += source.substring(startMark, endMark);
			}

			return(imageStr);
		}
	}

/* -- left() -------------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function left(source, len) {
	var strImage;

		if (isNaN(len)) {
			strImage = source;
		} else {
			strImage = source.substring(0, len);
		}

		return(strImage);
	}

/* -- right() ------------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function right(source, len) {
	var strImage;

		if (isNaN(len)) {
			strImage = strImage = source;
		} else {
			strImage = source.substring(source.length - len, source.length);
		}

		return(strImage);
	}

/* -- Join() -------------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function Join(source, delimeter) {
	var Count;
	var Joined = "";

		if (typeof(source) == "object") {
			for (Count = 0; Count < source.length; Count++) {
				if (Count == (source.length - 1)) {
					Joined += source[Count];
				} else {
					Joined += source[Count] + delimeter;
				}
			}

			return(Joined);
		} else {
			return("");
		}
	}

/* -- wordCount() --------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function wordCount(source, word) {
	var Count = 0;
	var Counter = 0;
	var endMark = source.length;
	var imageStr = source;

		if (word == null || word.length == 0) {
			return(source);
		} else {
			while(Count < endMark) {
				if (imageStr.substring(Count, Count + word.length) == word) {
					Counter++
					Count = Count + word.length;
				} else {
					Count++;
				}
			}

			return(Counter);
		}
	}

/* -- formatNum() --------------------------------------------------------------------
   ----------------------------------------------------------------------------------- */
	function formatNum(source) {
	var intLength = source.toString().length;
	var strFormatted = new String();
	var strSource = source.toString();
	var strEndDigits;

		if (inString(source.toString(), '.') != 0) {
			strEndDigits = right(source.toString(), 3);
			strSource = left(source, source.toString().length - 3);

			if (source.toString().length > 6) {
				strFormatted = source.toString().substring(0, (intLength - 6)) + ',';
				strFormatted += source.toString().substring((intLength - 3), (intLength - 6)) + ',';
				strFormatted += source.toString().substring((intLength - 3), source.toString().length);
				strFormatted += strEndDigits;
			} else if (source.toString().length > 3) {
				strFormatted = source.toString().substring(0, (intLength - 3)) + ',';
				strFormatted += source.toString().substring((intLength - 3), source.toString().length);
				strFormatted += strEndDigits;
			} else {
				strFormatted += strEndDigits;
			}

			if (source.toString().substring(inString(source.toString(), '.') + 1, source.toString().length).length == 1) {
				strFormatted += '0';
			}
		} else {
			if (source.toString().length > 6) {
				strFormatted = source.toString().substring(0, (intLength - 6)) + ',';
				strFormatted += source.toString().substring((intLength - 3), (intLength - 6)) + ',';
				strFormatted += source.toString().substring((intLength - 3), source.toString().length);
				strFormatted += '.00';
			} else if (source.toString().length > 3) {
				strFormatted = source.toString().substring(0, (intLength - 3)) + ',';
				strFormatted += source.toString().substring((intLength - 3), source.toString().length);
				strFormatted += '.00';
			} else {
				strFormatted += '.00';
			}
		}

		return(strFormatted);
	}



	/* ---------------------------------------------------------------------------- --
	    Function:       getAttrib
		Description:    Iterates through a delimited string returning the value from
						the matched name.

		Arguments:      src			-	string, contains delimited name=value attributes.
						name		-	string, the name within src to search for.

		Returns:        String containing value if successful otherwise null if key
						is not found.
	   ---------------------------------------------------------------------------- -- */

	function getAttrib(sSrc, sName) {
	var asElement = sSrc.split(';');
	var i;

		if (asElement.length > 0) {
			for (i = 0; i <= asElement.length - 1; i++) {
				if (asElement[i].length > 0) {
					if (inString(asElement[i].toString(), sName) != null) {
						if (trim.left(asElement[i].split(':')[1], ' ') == '\'\'' ||
							trim.left(asElement[i].split(':')[1], ' ') == 'none') {
							return('');
						} else {
							return(trim.left(asElement[i].split(':')[1], ' '));
						}
					}
				}
			}
		} else {
			return(null);
		}
	}

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

	function getParenthesses() {
	var intCount;
	var intStepBack;
	var strStepBack = new String();

		if (location.pathname.substring(0, 1) == '/') {
			intStepBack = wordCount(location.pathname, '/') - 2;
		} else {
			intStepBack = wordCount(location.pathname, '/') - 1;
		}

		if (intStepBack >= 1) {
			for (intCount = 0; intCount <= intStepBack - 1; intCount++) {
				strStepBack += '../';
			}
		}

		return(strStepBack);
	}

// Assign methods and properties to top level object. --------------------------------

	var trim = new Object();
	trim.left = _TrimLeft;
	trim.out = _TrimOut;
	trim.right = _TrimRight;

/* -- Common Script ----------------------------------------------------------- END -- */

/* =================================================================================== */