<!--

/*
		Author:  Eric Pepin
*/

/*#######################################NdexHasMap Constructor template #####################################*/
function NdexHashMap() {
	this.names =  new Array();
	this.index = -1;
}

NdexHashMap.prototype.remove = NdexHashMap_remove;
NdexHashMap.prototype.add = NdexHashMap_add;
NdexHashMap.prototype.get = NdexHashMap_get;
NdexHashMap.prototype.size = NdexHashMap_size;
NdexHashMap.prototype.hasNext = NdexHashMap_hasNext;
NdexHashMap.prototype.next = NdexHashMap_next;
NdexHashMap.prototype.reset = NdexHashMap_reset;

function NdexHashMap_remove(name) {
	for (var x=0; x < this.names.length; x++) {
		if (this.names[x].name == name) {
			tempArray1 = this.names.slice(0, x);
			tempArray2 = this.names.slice(x+1, this.names.length);
			if (tempArray1.length > 0 || x == 0) {
				this.names = tempArray1.concat(tempArray2);
				break;
			}
		}
	}
}

function NdexHashMap_add(name, value) {
	var isExistingNameFound = false;
	for (var x=0; x < this.names.length; x++) {
		if (this.names[x].name == name) {
			isExistingNameFound = true;
			break;
		}
	}
	if (!isExistingNameFound) {
		tempObject = new Object;
		this.names[this.names.length] = tempObject;
		tempObject.name = name;
		tempObject.value = value;
	}
}

function NdexHashMap_get(name) {
	var y = 0;
	isMatchFound = false;
	for (var x=0; x < this.names.length; x++) {
		if (this.names[x].name == name) {
			y = x;
			isMatchFound = true;
			break;
		}
	}
	return isMatchFound ? this.names[y].value : null;
}

function NdexHashMap_size() {
	return this.names.length;
}

function NdexHashMap_hasNext() {
	return this.index + 1 < this.names.length ? true : false;
}

function NdexHashMap_next() {
	returnValue = null;
	if (this.hasNext()) {
		this.index = this.index + 1;
		returnValue = this.names[this.index].name;
	}
	return returnValue;
}

function NdexHashMap_reset() {
	this.index = -1
}

/*#######################################End of NdexHasMap#####################################*/

/*#######################################NdexCookie Constructor Template#####################################*/
function NdexCookie(identifier, expiry, path, domain, secure) {
	this.map = new NdexHashMap();
	this.identifier = identifier ? identifier : "defaultidentifier";
	this.expiry = expiry ? new Date(new Date().getTime() + expiry) : null;
	this.path = path ? path : null;
	this.domain = domain ? domain : null;
	this.initialize();
}

NdexCookie.prototype.initialize = NdexCookie_initialize;
NdexCookie.prototype.save = NdexCookie_save;
NdexCookie.prototype.get = NdexCookie_get;
NdexCookie.prototype.set = NdexCookie_set;
NdexCookie.prototype.destroy = NdexCookie_destroy;
NdexCookie.isCookieSupportConfirmed = NdexCookie_isCookieSupportConfirmed;

function NdexCookie_initialize() {
	var cookieRef = document.cookie;
	var cookieStart = cookieRef.indexOf(this.identifier + "=");
	if (cookieStart != -1) {
		cookieStart = cookieStart + this.identifier.length + 1;
		var cookieEnd = cookieRef.indexOf(";") != -1 ? cookieRef.indexOf(";", cookieStart) + 1: cookieRef.length;
		var cookieValue = cookieRef.slice(cookieStart, cookieEnd);
		var firstSplit = cookieValue.split("&");//array of names:value pairs
		for (var x  = 0; x < firstSplit.length; x++) {
			var secondSplit = firstSplit[x].split(":");
			this.map.add(secondSplit[0], unescape(secondSplit[1]));//populate the ndexhashmap with name keys and their values
		}
	}
}

function NdexCookie_save() {
	var cookieValue = "";
	var cookie = "";
	var cookie2 = "";
	while (this.map.hasNext()) {
		var name = this.map.next();
		var value = this.map.get(name);
		cookieValue += name + ":" + escape(value) + "&";
	}
	this.map.reset();
	if (cookieValue != "") {
		cookieValue = cookieValue.slice(0, cookieValue.length - 1);
		cookie = this.identifier + "=" + cookieValue;
		if (this.expiry) {
			cookie += "; expires=" + this.expiry.toUTCString();
		}
		if (this.path) {
			cookie += "; path=" + this.path;
		}
		if (this.domain) {
			cookie += "; domain=" + this.domain;
		}
		if (this.secure) {
			cookie += "; secure";
		}
		document.cookie = cookie;
	}
}

function NdexCookie_get(name) {
	return this.map.get(name);
}

function NdexCookie_set(name, value) {
	this.map.add(name, value);
}

function NdexCookie_destroy(name) {
	this.map.remove(name);
}

function NdexCookie_isCookieSupportConfirmed() {
	var returnValue = false;
	var cookieRef = document.cookie = "testerCookie=testerValue";
	if (cookieRef && cookieRef.indexOf("testerCookie") != -1) {
		var aDate = new Date();
		aDate.setTime(aDate.getTime() - (1000 * 10));
		document.cookie = "testerCookie=testerValue;expires=" + aDate.toUTCString();
		returnValue = true;
	}
	return returnValue;
}
/*#######################################End of NdexCookie#####################################*/

/*#######################################NdexNumberParser Constructor template#####################################*/
function NdexNumberParser() {
	this.numberString = null;
	this.preParsedString = null;
	this.number = null;
	this.scale = 2;
	this.type = "money";
	this.language = "en";
	this.symbolRemoved = false;
	this.isForHtml = false;
}

NdexNumberParser.prototype.parse = NdexNumberParser_parse;
NdexNumberParser.prototype.parseForInstance = NdexNumberParser_parseForInstance;
NdexNumberParser.prototype.preParse = NdexNumberParser_preParse;
NdexNumberParser.prototype.format = NdexNumberParser_format;
NdexNumberParser.prototype.setScale = NdexNumberParser_setScale;
NdexNumberParser.prototype.getScale = NdexNumberParser_getScale;
NdexNumberParser.prototype.setType = NdexNumberParser_setType;
NdexNumberParser.prototype.getType = NdexNumberParser_getType;
NdexNumberParser.prototype.setLanguage = NdexNumberParser_setLanguage;
NdexNumberParser.prototype.getLanguage = NdexNumberParser_getLanguage;
NdexNumberParser.prototype.setSymbolRemoved = NdexNumberParser_setSymbolRemoved;
NdexNumberParser.prototype.isSymbolRemoved = NdexNumberParser_isSymbolRemoved;
NdexNumberParser.prototype.setFormatForHtml = NdexNumberParser_setFormatForHtml;


function NdexNumberParser_parse(numberAsString) {
	numberAsString = numberAsString + "";
	var returnValue = null;
	var preParsed = this.preParse(numberAsString);
	if (NdexNumberParser.isParsable(preParsed)) {
		this.numberString = numberAsString;//seized string
		this.number = Number(preParsed);
		this.preParsedString = preParsed;
		returnValue = this.number;
	}
	if (returnValue == null) {
		this.number = null;
	}
	return returnValue;
}

function NdexNumberParser_parseForInstance(numberAsString) {
	numberAsString = numberAsString + "";
	var preParsed = this.preParse(numberAsString);
	if (NdexNumberParser.isParsable(preParsed)) {
		this.numberString = numberAsString;//seized string
		this.number = Number(preParsed);
		this.preParsedString = preParsed;
	}
	else {
		this.number = null;
	}
	return this;
}

function NdexNumberParser_preParse(numberAsString) {//private business logic
	var numberAsStringTemp = null;
	if (numberAsString != null) {
		if (this.type == "money") {
			numberAsString = numberAsString.replace(/[\s]/g, "");
			if (numberAsString.charAt(0) == "$" || numberAsString.charAt(numberAsString.length - 1) == "$") {
				if (numberAsString.match(/[$]/g).length == 1) {
					numberAsString = numberAsString.replace(/[$]/, "");
				}
			}
			if (this.language == "en") {
				numberAsString = numberAsString.replace(/[,]/g, "");
			}
			else {
				numberAsString = numberAsString.replace(/[,]/g, ".");
			}
		}
		else if (this.type == "percentage") {
			numberAsStringTemp = numberAsString.replace(/[\s]/g, "");
			if (numberAsStringTemp.charAt(numberAsString.length - 1) == "%") {
				if (numberAsStringTemp.match(/[%]/g).length == 1) {
					numberAsString = numberAsStringTemp.replace(/[%]/, "");
				}
			}
			if (this.language == "en") {
				numberAsString = numberAsString.replace(/[,]/g, "");
			}
			else {
				numberAsString = numberAsString.replace(/[,]/g, ".");
			}
		}
		else {
			numberAsString = numberAsString.replace(/[\s]/g, "");
			if (this.language == "en") {
				numberAsString = numberAsString.replace(/[,]/g, "");
			}
			else {
				numberAsString = numberAsString.replace(/[,]/g, ".");
			}
		}
	}
	return numberAsString;
}

function NdexNumberParser_format() {
	if (this.number == null) {
		return null;
	}
	scaledNumber = this.scale != null && this.scale > 0 ? Math.round(this.number*Math.pow(10,this.scale))/Math.pow(10,this.scale) : this.number;
	aString = this.scale != null && this.scale > 0 ? scaledNumber + "" : (this.scale != null && this.scale == 0 ? Math.round(scaledNumber) + "" : scaledNumber + "");

	index = aString.indexOf(".") != -1 ? aString.indexOf(".") : aString.length;
	slicedString = aString.slice(0, index);
	remainder = aString.slice(index, aString.length);
	if (this.scale != null && this.scale > 0) {
		if (remainder.indexOf(".") == -1) {
			remainder = "." + remainder;
		}
		remainderSliced = remainder.slice(1, remainder.length);
		while (remainder.length < this.scale + 1) {
			remainder = remainder + "0";
		}
	}
	count = 1;
	slicedString2 = slicedString;
	if (slicedString.length >=4) {
		for (var x = slicedString.length - 1; x >= 0; x--) {
			if (count % 3 == 0) {
				if (x != 0 && ( slicedString2.slice(0, x) != "-"))
				{
					if (!this.isForHtml) {
						slicedString2 = slicedString2.slice(0, x) + (this.language && this.language == "en" ? "," : " ") + slicedString2.slice(x, slicedString2.length);
					}
					else {
						slicedString2 = slicedString2.slice(0, x) + (this.language && this.language == "en" ? "," : "&nbsp;") + slicedString2.slice(x, slicedString2.length);
					}
				}
				else {
					slicedString2 = slicedString2.slice(0, x) + slicedString2.slice(x, slicedString2.length);
				}

			}
			count++;
		}
	}
	returnValue = "";

    if (this.type == "money") {
		if (this.symbolRemoved) {
			returnValue = this.language == "en" ? slicedString2 + remainder : (slicedString2 + remainder).replace(/[.]/, ",");
		}
		else {
			returnValue = this.language == "en" ? "$" + slicedString2 + remainder : (slicedString2 + remainder + "$").replace(/[.]/, ",");
		}
	}
	else if (this.type == "percentage") {
		if (this.symbolRemoved) {
			returnValue = this.language == "en" ? slicedString2 + remainder : (slicedString2 + remainder).replace(/[.]/, ",");
		}
		else {
			returnValue = this.language == "en" ? slicedString2 + remainder + "%" : (slicedString2 + remainder + "%").replace(/[.]/, ",");
		}
	}
	else {
		returnValue = this.language == "en" ? slicedString2 + remainder : (slicedString2 + remainder).replace(/[.]/, ",");
	}
	return returnValue;
}

function NdexNumberParser_setFormatForHtml(isForHtmlValue) {
	if (isForHtmlValue) {
		this.isForHtml = true;
	}
	else {
		this.isForHtml = false;
	}
}

function NdexNumberParser_setScale(aScale) {
	if (aScale != null) {
		if (aScale >= 0 && aScale % 1 == 0) {
			this.scale = aScale;
		}
	}
	else {
		this.scale = null;
	}
}

function NdexNumberParser_getScale(aScale) {
	return this.scale;
}

function NdexNumberParser_setType(aType) {
	aType = aType.toLowerCase();
	if (aType == "money" || aType == "percentage" || aType == "number") {
		this.type = aType;
	}
}

function NdexNumberParser_getType() {
	return this.type;
}

function NdexNumberParser_setLanguage(aLanguage) {
	aLanguage = aLanguage.toLowerCase();
	if (aLanguage == "fr" || aLanguage == "en") {
		this.language = aLanguage;
	}
}

function NdexNumberParser_getLanguage() {
	return this.language;
}

function NdexNumberParser_setSymbolRemoved(isSymbolRemoved) {
	this.symbolRemoved = isSymbolRemoved;
}

function NdexNumberParser_isSymbolRemoved() {
	return this.symbolRemoved;
}

NdexNumberParser.isParsable = NdexNumberParser_isParsable;
function NdexNumberParser_isParsable(numberAsString) {
	var parsedNumber = null;
	if (numberAsString != null && numberAsString != "") {
		parsedNumber = Number(numberAsString);
		if (!isNaN(parsedNumber)) {
			return true;
		}
		else {
			return false;
		}
	}
	else {
		return false;
	}
}
/*#######################################End of NdexNumberParser#####################################*/

/*#######################################NdexDateParser Constructor template#####################################*/
function NdexDateParser(language) {
	this.language = language && language != "en" ? "fr" : "en";
	this.errorCode;
}

NdexDateParser.prototype.parse = NdexDateParser_parse;
NdexDateParser.prototype.isTokensUnParseable = NdexDateParser_isTokensUnParseable;
NdexDateParser.prototype.getTokensForDate = NdexDateParser_getTokensForDate;
NdexDateParser.prototype.format = NdexDateParser_format;
NdexDateParser.prototype.getLanguage = NdexDateParser_getLanguage;
NdexDateParser.ERRORCODE_NO_ERROR = 0;
NdexDateParser.ERRORCODE_WRONG_FORM = 1;
NdexDateParser.ERRORCODE_DAY_OUT_OF_RANGE = 2;
NdexDateParser.ERRORCODE_MONTH_OUT_OF_RANGE = 3;
NdexDateParser.ERRORCODE_YEAR_OUT_OF_RANGE = 4;
NdexDateParser.ERRORCODE_DAY_TOO_LARGE = 5;


function NdexDateParser_parse(stringToParse) {
	var tokens = new Array();
	var delimiter;
	var date = null;
	stringToParse = NdexStringManipulator.trim(stringToParse);
	var delimiters = new Array(" ", "/", "-");
	var delimiterIndex;
	for (var x = 0; x < 3; x++) {
		delimiterIndex = stringToParse.indexOf(delimiters[x]);
		if (delimiterIndex > -1) {
			break;
		}
	}
	if (delimiterIndex > -1) {
		delimiter = stringToParse.charAt(delimiterIndex);
	}
	if (!delimiter) {
		this.errorCode = NdexDateParser.ERRORCODE_WRONG_FORM;
		return date;
	}
	tokens = stringToParse.split(delimiter);
	if (tokens.length != 3) {
		this.errorCode = NdexDateParser.ERRORCODE_WRONG_FORM;
		return date;
	}
	else {
		if (!this.isTokensUnParseable(tokens)) {
			tokens = this.getTokensForDate(tokens);
			if (tokens) {
				date = new Date(Number(tokens[0]), Number(tokens[1]), Number(tokens[2]));
			}
			else {
				return date;
			}
		}
		else {
			this.errorCode = NdexDateParser.ERRORCODE_WRONG_FORM;
			return date;
		}
	}
	this.errorCode = NdexDateParser.ERRORCODE_NO_ERROR;
	return date;
}

function NdexDateParser_isTokensUnParseable(tokens) {
	var isUnParseable = false;
	for (var x = 0; x < tokens.length; x++) {
		 if (isNaN(tokens[x])) {
				isUnParseable = true;
				break;
		 }
		 else if(Number(tokens[x]) % 1 != 0) {
					isUnParseable = true;
					break;
		 }
		 else if(Number(tokens[x]) < 0) {
					isUnParseable = true;
					break;
		 }
	}
	return isUnParseable;
}

function NdexDateParser_getTokensForDate(tokens) {
	var dateTokens = null;
	var dayToken = Number(tokens[2]);
	if (dayToken == 0 || dayToken > 31) {
		this.errorCode = NdexDateParser.ERRORCODE_DAY_OUT_OF_RANGE;
		return dateTokens;
	}
	var monthToken = Number(tokens[1]) - 1;
	if (monthToken  <= 0 && monthToken > 11) {
		this.errorCode = NdexDateParser.ERRORCODE_MONTH_OUT_OF_RANGE;
		return dateTokens;
	}
	var yearToken = Number(tokens[0]);
	if (yearToken >= 0 && yearToken < 100) {
		var today = new Date();
		var currentYear = today.getFullYear();
		var centuries = parseInt(currentYear/100);
		var base = centuries * 100;
		yearToken = base + yearToken;
	}
	if (yearToken < 0 || yearToken > 100000) {
		this.errorCode = NdexDateParser.ERRORCODE_YEAR_OUT_OF_RANGE;
		return dateTokens;
	}
	var baseDate = new Date(yearToken, monthToken, 28);
	var testDate = new Date(baseDate.getTime());
	var maximumDayInMonth = 28;
	while (testDate.getMonth() == monthToken) {
			 maximumDayInMonth = testDate.getDate();
			 testDate.setDate(testDate.getDate() + 1);
	}
	if (dayToken >  maximumDayInMonth) {
		this.errorCode = NdexDateParser.ERRORCODE_DAY_TOO_LARGE;
		return dateTokens;
	}
	tokens[0] = String(yearToken);
	tokens[1] = String(monthToken);
	tokens[2] = String(dayToken);
	dateTokens = tokens;
	return dateTokens;
}

function NdexDateParser_getLanguage() {
	return this.language;
}

function NdexDateParser_format(aDateObj) {
	var year = aDateObj.getFullYear();
	var month = String(aDateObj.getMonth() + 1 < 10 ? "0" + (aDateObj.getMonth() + 1) :  aDateObj.getMonth() + 1);
	var day = String(aDateObj.getDate() < 10 ? "0" + aDateObj.getDate() : aDateObj.getDate());
	var delimiter = this.language == "fr" ? "-" : "/";

	return year + delimiter + month + delimiter + day;
}
/*#######################################End of NdexDateParser#####################################*/

/*#######################################NdexStringManipulator Constructor template#####################################*/
function NdexStringManipulator() {
}

NdexStringManipulator.trim = NdexStringManipulator_trim;
NdexStringManipulator.getScale = NdexStringManipulator_getScale;

function NdexStringManipulator_trim(aString) {
	var start = 0;
	var end = aString.length;
	var x;
	for (x = 0; x < aString.length; x++) {
		if (aString.charCodeAt(x) != 32) {
			start = x;
			break;
		}
	}
	for (var y = aString.length - 1; y >= 0; y--) {
		if (aString.charCodeAt(y) != 32) {
			end = y;
			break;
		}
	}
	return x != aString.length ? aString.slice(start, end + 1) : "";
}

function NdexStringManipulator_getScale(aNumber, aLanguage) {
	var scale = -1;
	var language = !aLanguage ? "en" : (aLanguage != "fr" ? "en" : "fr");
	var parser = new NdexNumberParser();
	parser.setType("number");
	parser.setLanguage(language);
	if (parser.parse(String(aNumber)) == null) {
		return scale;
	}
	var start = -1;
	scale = 0;
	if ((start = aNumber.indexOf(".")) != -1) {
		var sliced = aNumber.slice(start, aNumber.length);
		scale = sliced.length;
	}
	return scale;
}
/*#######################################End of NdexStringManipulator#####################################*/

/*#######################################NdexTimer Constructor template#####################################*/
function NdexTimer(duration, frequency) {
	if (window.NDEX_TIMER) {
		//this = null;
		alert("only one instance allowed");
		return;
	}
		window.NDEX_TIMER = this;
		this.duration = duration;
		this.frequency = frequency ? frequency : 1000;
}


NdexTimer.prototype.start = NdexTimer_start;
NdexTimer.prototype.stop = NdexTimer_stop;


function NdexTimer_start() {
	if (!this.started) {
		this.started = true;
		this.target = (new Date().getTime()) + (this.duration);
    }
	verify_NDEX_TIMER_Timeout();
}

function NdexTimer_stop() {
	if (this.started) {
		this.started = false;
	}
}

function verify_NDEX_TIMER_Timeout() {
	if (window.NDEX_TIMER.started) {
		var present = new Date().getTime();
		if (present >= window.NDEX_TIMER.target) {
			if (window.executeTimerAction) {
				window.NDEX_TIMER.started = false;
				window.executeTimerAction();
			}
			else {
				window.NDEX_TIMER.started = false;
				alert("their must be a user-defined executeTimerAction method present");
			}
		}
		else {
			setTimeout("verify_NDEX_TIMER_Timeout()", window.NDEX_TIMER.frequency);
		}
	}
}
/*#######################################End of NdexTimer#####################################*/

/*#######################################Beginning of flip.js #####################################*/

function imageLoad() {
        if (document.images) {
                var imgFiles = imageLoad.arguments;
                if (document.preloadArray==null) document.preloadArray = new Array();
                var i = document.preloadArray.length;
                with (document) for (var j=0; j<imgFiles.length; j++){
                        preloadArray[i] = new Image();
                        preloadArray[i++].src = imgFiles[j];
                }
        }
}

function change(imageNameSpace,imageURI) {
	if (document.images) {
		imageObj = document.images[imageNameSpace];
		imageObj.src = imageURI;
	}
}

/*#######################################End of flip.js#####################################*/

/*#######################################Beginning of Ajax Script Invokation #####################################*/

function invokeAjax(variableName, functionName, key, isAsynchronous, requestParameters) {
  	if (window.XMLHttpRequest) {// Non-IE.
		eval(variableName + ' = new XMLHttpRequest();');
	}
    else {// IE.
		eval(variableName + ' = new ActiveXObject("Microsoft.XMLHTTP");');
	}
	eval(variableName + '.onreadystatechange = ' + functionName + ';');
	eval(variableName + '.open("POST", "' + key + '.ajx", ' + isAsynchronous + ');');
	eval(variableName + '.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");');
	eval(variableName + '.send("' + requestParameters + '");');
}

/*#######################################End of Ajax Script Invokation #####################################*/

//-->