//
// global constants
//
var MAX_UPSELLS = 5;
// 
// State of the view gif...
//
var OPEN_TOGGLE_STATE = 'minus.gif';
var OPEN_TOGGLE_ALT = 'Open';
var CLOSED_TOGGLE_STATE = 'add.gif';
var CLOSED_TOGGLE_ALT = 'Close';

var ICON_TICK_SRC = "/media/FBD/images/icon_tick01.jpg";
var ICON_ERROR_SRC = "/media/FBD/images/icon_close3.jpg";
var ICON_HELP_SRC = "/media/FBD/images/icon_help.gif";

//
// The class applied to long fields when active
//
var ACTIVE_LONG_CLASS = "activeLong";
var INACTIVE_LONG_CLASS = "long";

var useReturnedText = "false";



/**************************************************************
kainos_onFieldFocus

highlights the current row
***************************************************************/
function kainos_onFieldFocus(fieldId, rowId) {
	var elem = document.getElementById(fieldId);
	var helpElem = document.getElementById(fieldId+".helpText");
	if (helpElem!=null) {
		kainos_showHelp(helpElem.id);
	}
	var rowElem = document.getElementById(fieldId+".row");
	if (rowElem==null && rowId!=null) {
		rowElem = document.getElementById(rowId);
	}
	if (rowElem!=null) {
		//alert("gets here " + rowElem.getAttribute("class"));
		rowElem.className = "active";
		//rowElem.setAttribute("class", "active");
		//rowElem.style = "background-color:#000000";
	}
	
}

/**************************************************************
kainos_onFieldFocusLong

highlights the current row using a style which preserves the 
spacing of a long field
***************************************************************/
function kainos_onFieldFocusLong(fieldId, rowId) {
	var elem = document.getElementById(fieldId);
	var helpElem = document.getElementById(fieldId+".helpText");
	if (helpElem!=null) {
		kainos_showHelp(helpElem.id);
	}
	var rowElem = document.getElementById(fieldId+".row");
	if (rowElem==null && rowId!=null) {
		rowElem = document.getElementById(rowId);
	}
	if (rowElem!=null) {
		//alert("gets here " + rowElem.getAttribute("class"));
		rowElem.className = "activeLong";
		//rowElem.setAttribute("class", "active");
		//rowElem.style = "background-color:#000000";
	}
	
}

function kainos_onFieldFocusClassName(fieldId, className) {
	var elem = document.getElementById(fieldId);
	var helpElem = document.getElementById(fieldId+".helpText");
	if (helpElem!=null) {
		kainos_showHelp(helpElem.id);
	}
	var rowElem = document.getElementById(fieldId+".row");
	if (rowElem!=null) {
		rowElem.className = className;
	}

}

function kainos_onFieldBlurSelected(fieldId, rowId, errorTag, errorText) {
	var rowElem = document.getElementById(fieldId+".row");
	if (rowElem==null && rowId!=null) {
		rowElem = document.getElementById(rowId);
	}
	if (rowElem!=null) {
		rowElem.className = "";
	}
	var elem = document.getElementById(fieldId);
	if ((elem.value==-1) || (elem.value=="")) {
//		var errorTagx = document.getElementById(errorTag);
		var errorTagText = document.getElementById(errorText + ".incorrect");
		kainos_showErrorRegardless(errorTag, errorTagText.innerHTML);
		
	} else {
		kainos_hideError();
	}
	
}

function kainos_onFieldBlur(fieldId, rowId) {
	var rowElem = document.getElementById(fieldId+".row");
	if (rowElem==null && rowId!=null) {
		rowElem = document.getElementById(rowId);
	}
	if (rowElem!=null) {
		rowElem.className = "";
	}
}

function kainos_onFieldBlurClassName(fieldId, className) {
	var rowElem = document.getElementById(fieldId+".row");
	if (rowElem!=null) {
		rowElem.className = className;
	}
}


var accordionBeingExpanded = false;

//
// An accordian array
//
//  Author Kevin Bushe
//

var postAccordionComplete = "";

function kainos_openViewStateGeneric(nameToCheck, viewAccordianArray) {
	var first = true;

	var showId = null;
	var showElem = document.getElementById(nameToCheck+"Detail");
	if (showElem) {
	    showId = showElem.id;
	}
	var showClickItem = document.getElementById(nameToCheck+"Img");
	if (showClickItem) {
		showClickItem.alt = showClickItem.alt.replace(OPEN_TOGGLE_ALT,CLOSED_TOGGLE_ALT);
		showClickItem.title = showClickItem.alt;
	}
	
	accordionBeingExpanded = false;
	for(var i=0;i<viewAccordianArray.length;i++) {
		var clickItem = document.getElementById(viewAccordianArray[i]+"Img");
		var itemToHideShowElem = document.getElementById(viewAccordianArray[i]+"Detail");
		if (itemToHideShowElem!=null) {
			var itemIdToHideShow = itemToHideShowElem.id;
			var imgSrc = null;
			if (clickItem) {
				imgSrc = clickItem.src;
			}
			if (nameToCheck!=viewAccordianArray[i]) {
				var clickItemInt = document.getElementById(viewAccordianArray[i]+"Img");
				var itemIdToHideShowIntElem = document.getElementById(viewAccordianArray[i]+"Detail");
				if (itemIdToHideShowIntElem!=null) {
					var itemIdToHideShowInt = itemIdToHideShowIntElem.id;
					var imgSrcInt = null;
					if (clickItemInt) {
						imgSrcInt = clickItemInt.src;
					}
					if (nameToCheck!=viewAccordianArray[i]) {
						var newSrc = null;
						if (imgSrcInt) {
							newSrc = imgSrcInt.replace(OPEN_TOGGLE_STATE,CLOSED_TOGGLE_STATE);
						}
						if (first) {
							accordionBeingExpanded = true;
							jQuery('#' + itemIdToHideShowInt).slideUp("slow",function() {
							    if (showId) {
							       if (showClickItem) {
								   	var imgSrcOpen = showClickItem.src;
								   	var newSrcOpen = imgSrcOpen.replace(CLOSED_TOGGLE_STATE,OPEN_TOGGLE_STATE);
								   	showClickItem.src = newSrcOpen;
								   }
								   jQuery('#' + showId).slideDown("slow", function () {
										if (postAccordionComplete != "") {
											eval(postAccordionComplete);
										}
										postAccordionComplete = "";
									});
								}
							});
						} else {
							jQuery('#' + itemIdToHideShowInt).slideUp("slow");
						}	
						if (clickItemInt) {
							clickItemInt.src = newSrc;
						}
					}
				} 
			}
		}
	}
	if (accordionBeingExpanded == false) {
		if (showId) {
			if (showClickItem) {
			  	var imgSrcOpen = showClickItem.src;
			   	var newSrcOpen = imgSrcOpen.replace(CLOSED_TOGGLE_STATE,OPEN_TOGGLE_STATE);
			  	showClickItem.src = newSrcOpen;
			}
			jQuery('#' + showId).slideDown("slow", function () {
				if (postAccordionComplete != "") {
					eval(postAccordionComplete);
				}
				postAccordionComplete = "";
			});
		}	
	}
	
}





/**
Disables elements based on ids
*/
function kainos_disableElementsBasedOnIds(listOfElements,disableElements) {
	var locb = listOfElements.split(",");
	for(var i=0;i<locb.length;i++) {
		var elem = document.getElementById(locb[i]);
		if (elem) {
			if (disableElements) {
				elem.disabled = true;
				
				if (elem.type=="button") {
					if (elem.className.indexOf("Disabled")==-1) {
						elem.className = elem.className + "Disabled";
					}
				}
			} else {
				elem.disabled = false;
				if (elem.type=="button") {
					var clName  = elem.className;
					var ix = clName.indexOf("Disabled");
					if (ix!=-1) {
						var newClassName = clName.substring(0,ix);
						elem.className = newClassName;
					}
				}
			}
		}
	}
}

//
// An accordian array
//
//  Author Kevin Bushe
//

function kainos_closeStatesGeneric(viewAccordianArray) {

	for(var j=0;j<viewAccordianArray.length;j++) {
		var clickItemInt = document.getElementById(viewAccordianArray[j]+"Img");
		var itemIdToHideShowIntElem = document.getElementById(viewAccordianArray[j]+"Detail");
		if (itemIdToHideShowIntElem!=null) {
			var itemIdToHideShowInt = itemIdToHideShowIntElem.id;
			var imgSrcInt = clickItemInt.src;
			var imgAltInt = clickItemInt.alt;
			var newSrc = imgSrcInt.replace(OPEN_TOGGLE_STATE,CLOSED_TOGGLE_STATE);
			var newAlt = imgAltInt.replace(CLOSED_TOGGLE_ALT, OPEN_TOGGLE_ALT);
			jQuery('#' + itemIdToHideShowInt).slideUp("slow");	
			clickItemInt.src = newSrc;
			clickItemInt.alt = newAlt; 
			clickItemInt.title = clickItemInt.alt;
		}
	}

}
	



//
// Toggle the view state of an element - by default should be closed
//
//  Author Kevin Bushe
//
function kainos_toggleViewState(clickItemId, itemIdToHideShow) {
	var clickItem = document.getElementById(clickItemId);
	var imgSrc = clickItem.src;
	var imgAltInt = clickItem.alt;
	var newSrc;
	if (imgSrc.indexOf(OPEN_TOGGLE_STATE)!=-1) {
		newSrc = imgSrc.replace(OPEN_TOGGLE_STATE,CLOSED_TOGGLE_STATE);
		imgAltInt = imgAltInt.replace(CLOSED_TOGGLE_ALT, OPEN_TOGGLE_ALT);
		kainos_setVisibility(itemIdToHideShow, false);
	} else {
		newSrc = imgSrc.replace(CLOSED_TOGGLE_STATE, OPEN_TOGGLE_STATE);
		kainos_setVisibility(itemIdToHideShow, true);
		imgAltInt = imgAltInt.replace(OPEN_TOGGLE_ALT, CLOSED_TOGGLE_ALT);
	}
	clickItem.src = newSrc;
	clickItem.alt = imgAltInt;
	clickItem.title = clickItem.alt;
}


//
// Set any element with a style visible or hidden
//
//  Author Kevin Bushe
//
function kainos_setVisibility(elementId, visible) {
	var vals = elementId.split(',');
	for(var i=0;i<vals.length;i++) {
		var element = document.getElementById(vals[i]);
		if (element!=null) {
			kainos_setVisibilityOfElement(element, visible);
		}
	}

}


function kainos_setClaims(numberOfClaims) {
	
	for(var i=0;i<numberOfClaims;i++) {		
		var claim = "claim" + i;
		var obj = document.getElementById(claim);
		if (obj==null) {
			objN = document.getElementById("tempClaimHidden");
			var vals = objN.innerHTML;
			vals.replace("XXX", "" + i);
			//alert(vals);
		}
	}
}

//
// Sets visibily of given element 
//
// Author Kevin Bushe 
// 
function kainos_setVisibilityOfElement(element, visible) {
	if (visible) {
		jQuery('#' + element.id).slideDown("slow");
	} else {
		jQuery('#' + element.id).slideUp("slow");
	}	
}


//
// Sets an element as hidden 
//
// Author Kevin Bushe 
// 
function kainos_setHideElement(element) {
	if (element.style) {
		element.style.visibility="hidden";
		element.style.display="none";
	} 
}

//
// Sets an element as shown
//
// Author Kevin Bushe 
// 
function kainos_setShowElement(element) {
	if (element.style) {
	element.style.visibility="visible";
	element.style.display="block";
	} 
}


//
// Author Kevin Bushe
// 
function kainos_showFirstCountElementsInList(elementName, count, maxsize) {
  var vars = "";
  var newCount = count - 1;
  
  if(document.getElementById('preClaims'))
  {
	  var preClaims = document.getElementById('preClaims');
	  
	  if (count == 1 || count == -1 || newCount > maxsize) {
	  	kainos_setHideElement(preClaims);
	  }
	  else {
	  	kainos_setShowElement(preClaims);
	  }
  }
  
  if (newCount > maxsize) {
  	newCount = 0;
  }
  
  for(var i=0;i<maxsize;i++) {
  	var element = document.getElementById(elementName+i);
  	if (element!=null) {
  		kainos_setVisibilityOfElement(element,(i<newCount));
  	}
  }
}

//
// toggles the visibility of given ids
//
// Author Kevin Bushe
// 

function kainos_toggleVisibility(elementIds) {
	var vals = elementIds.split(',');
	for(var i=0;i<vals.length;i++) {
		var element = document.getElementById(vals[i]);
		if (element == null) {
			continue;
		}
		if (element.style.visibility == 'visible' || element.style.display == 'block') {
			kainos_setVisibilityOfElement(element, false);
		} else {
			kainos_setVisibilityOfElement(element, true);
		}
	}
}


//
// toggles the color of a given element depending on value of checkbox
//
// Author Jonathan Holmes
//
function changeTextColor(sender, elementID, defaultColor, checkedColor) {
    var el = document.getElementById(elementID);
    if (sender.checked)
    {
        el.style.color = checkedColor;
    }
    else
    {
        el.style.color = defaultColor;
    }
}

/**********************************************************************
	Function:		kainos_addCommasToString
	Description:	strip commas then add properly
					strip first decimal and all following characters
	Changes:		
	Mark Dunlop		Created		07/10/2007
**********************************************************************/
function kainos_addCommasToString(stringWithoutCommas)
{	
	var retVal = '0';
	var splitString = stringWithoutCommas.split('.');
	var result = '';
	var wholePart = splitString[0];
	var len = wholePart.length; 

	if (len > 3) 
	{
		var comaIdx = len % 3;
	
		if (comaIdx) {
			result = wholePart.substr(0, comaIdx) + ',';
		}
		for (; comaIdx < len; comaIdx += 3 ) {
			result += wholePart.substr(comaIdx, 3) + ',';
		}
		
		// cut last coma off
		wholePart = result.substr(0, result.length-1);
	} 	
	if (splitString.length==1) {
		retVal = wholePart;
	} else {
		retVal = wholePart + "." + splitString[1];
	}
	return retVal;
}
/**********************************************************************
	Function:		kainos_monetaryFormat
	Description:	strip commas then add properly
					strip first decimal and all following characters
	Changes:		
	Mark Dunlop		Created		07/10/2007
**********************************************************************/
function kainos_monetaryFormat(fieldToCheckName)
{	
	var monetaryField = document.getElementById(fieldToCheckName);
	
	if(monetaryField != null)
	{
		var monetaryValue = monetaryField.value;
	
		monetaryValue = kainos_replaceAll(monetaryValue, ',' , '');
	
		var firstInstanceOfDecimal = monetaryValue.indexOf('.');
		if(firstInstanceOfDecimal != -1)
		{
			var splitOnDecimal = monetaryValue.split('.');
			monetaryValue = splitOnDecimal[0];
		}
	
		var result = '';
		var len = monetaryValue.length; 

		if (len > 3) 
		{
			var comaIdx = len % 3;
	
			if (comaIdx) {
				result = monetaryValue.substr(0, comaIdx) + ',';
			}
			for (; comaIdx < len; comaIdx += 3 ) {
				result += monetaryValue.substr(comaIdx, 3) + ',';
			}
		
			// cut last coma off
			monetaryValue = result.substr(0, result.length-1);
		} 	
	
		monetaryField.value = monetaryValue;
	}
}

/**********************************************************************
	Function:		kainos_monetaryFormatThenValidate
	Description:	call the monetary format function then validate
	Changes:		
	Mark Dunlop		Created		03/10/2007
**********************************************************************/
function kainos_monetaryFormatThenValidate(objectName, fieldToCheckName)
{	
	kainos_monetaryFormat(fieldToCheckName);
	
	//Now we have it correctly formatted, validate it
	kainos_dwrCheckField(objectName, fieldToCheckName);
}

/**********************************************************************
	Function:		kainos_replaceAll
	Description:	replace all instances of a string
	Changes:		
	Mark Dunlop		Created		03/10/2007
**********************************************************************/
function kainos_replaceAll(text, strA, strB) 
{
    while ( text.indexOf(strA) != -1)
    {
        text = text.replace(strA,strB);
    }
    return text;
}

/**********************************************************************
	Function:		kainos_dwrCrossCheckField
	Description:	Check a single field against the dwr object
	Changes:		
	Kevin Bushe		Created		01/08/2007
**********************************************************************/
function kainos_dwrCrossCheckField(objectName, fieldToCheckNames, fieldCheckType, responseId, useReturnedTextVal)
{
	var fields = fieldToCheckNames.split(",");
    var variableNames = "DUMMY";
    var variableValues = "__NULL__";
    if (useReturnedTextVal) {
    	useReturnedText = "true";
    } else {
    	useReturnedText = "false";
    }
	for(var i=0;i<fields.length;i++) {
	    
		var elementToCheck = document.getElementById(fields[i]);
		if (elementToCheck) {
			var fieldToCheckValue = elementToCheck.value;
			
			//if this is a radio button we're interested in whether it's checked or not
			if(elementToCheck.type == "radio")
			{
				 if(elementToCheck.checked)
				 {fieldToCheckValue = "true";}
				 else
				 {fieldToCheckValue = "false";}
			}
			//make sure all the fields we are checking have a value
			if(fieldToCheckValue == null || fieldToCheckValue == "")
			{
			   // if they are empty or null return and display an error
			   var labelStatus = document.getElementById(responseId + "Status");
			   kainos_addImage(labelStatus, false);
			   return;
			}
			variableNames = variableNames + "::" + fields[i];
			variableValues = variableValues + "::" + fieldToCheckValue;
		}
	}
	objectName.crossValidateObject(variableNames, 
		variableValues, fieldCheckType, responseId, kainos_dwrGenericResponse);
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

/**********************************************************************
	Function:		kainos_dwrCheckFieldCheckAsOther
	Description:	Check a single field against the dwr object
	Changes:		
	Kevin Bushe		Created		01/08/2007
**********************************************************************/
function kainos_dwrCheckFieldCheckAsOther(objectName, actualField, checkAsField)
{
	var elementToCheck = document.getElementById(actualField);
	if (elementToCheck) {
		var fieldToCheckValue = elementToCheck.value;
		objectName.validateFieldGivenValue(checkAsField, 
			fieldToCheckValue, kainos_dwrGenericResponse);
	}
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

/**********************************************************************
	Function:		kainos_dwrCheckField
	Description:	Check a single field against the dwr object
	Changes:		
	Kevin Bushe		Created		01/08/2007
**********************************************************************/
function kainos_dwrCheckField(objectName, fieldToCheckName)
{
	var elementToCheck = document.getElementById(fieldToCheckName);
	if (elementToCheck) 
	{
		var fieldToCheckValue = elementToCheck.value.trim();

		if((fieldToCheckValue == "") || (fieldToCheckValue == null))
		{
			var labelStatus = document.getElementById(fieldToCheckName + "Status");
			kainos_addImage(labelStatus, false);
		}
		else
		{	
			objectName.validateFieldGivenValue(fieldToCheckName, 
				fieldToCheckValue, kainos_dwrGenericResponse);
		}
	}
	var rowElem = document.getElementById(fieldToCheckName+".row");
	if (rowElem) 
	{
		rowElem.className = "";
	}		
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

/**********************************************************************
	Function:		kainos_dwrCheckNonMandatoryField
	Description:	Check a single field against the dwr object. 
					Does not throw an error 
	Changes:		
	Heather campbell		Created		10/10/2008
**********************************************************************/
function kainos_dwrCheckNonMandatoryField(objectName, fieldToCheckName)
{
	var elementToCheck = document.getElementById(fieldToCheckName);
	if (elementToCheck) 
	{
		var fieldToCheckValue = elementToCheck.value;
		
			objectName.validateFieldGivenValue(fieldToCheckName, 
				fieldToCheckValue, kainos_dwrGenericResponse);
	}
	var rowElem = document.getElementById(fieldToCheckName+".row");
	if (rowElem) 
	{
		rowElem.className = "";
	}		
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

/**********************************************************************
	Function:		kainos_dwrCheckTwoNumberFields
	Description:	Check two number fields against the dwr object
	Changes:		
	Mark Dunlop		Created		17/08/2007
**********************************************************************/
function kainos_dwrCheckTwoFields(objectName, fieldToCheckName1, fieldToCheckName2)
{
	var elementToCheck1 = document.getElementById(fieldToCheckName1);
	var elementToCheck2 = document.getElementById(fieldToCheckName2);
	if (elementToCheck1 && elementToCheck2) {
		var fieldToCheckValue = elementToCheck1.value + elementToCheck2.value;
		objectName.validateFieldGivenValue(fieldToCheckName, 
			fieldToCheckValue, kainos_dwrGenericResponse);
	}
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

/**********************************************************************
	Function:		kainos_dwrCheckOneOfTwoFieldsChange
	Description:	Check multiple fields against the dwr object
					triggered by the first part changing. Providing
					the second part has a value
	Changes:		
	Heather Campbell	Created		29/09/2008
**********************************************************************/
function kainos_dwrCheckOneOfMultipleFieldsChange(objectName, fieldChanged, fieldToCheckNames, fieldCheckType, responseId)
{
	var fields = fieldToCheckNames.split(",");
    var variableNames = "DUMMY";
    var variableValues = "__NULL__";
	for(var i=0;i<fields.length;i++) {
	  if (fields[i] != fieldChanged){
		var elementToCheck = document.getElementById(fields[i]);
		if (elementToCheck) {
			var fieldToCheckValue = elementToCheck.value;
			if(fieldToCheckValue == null || fieldToCheckValue == "")
			{	
				elementToCheck.focus();
				return;
			}
		}
	  }
	}
	kainos_dwrCrossCheckField(objectName, fieldToCheckNames, fieldCheckType, responseId)
}

/**********************************************************************
	Function:		kainos_dwrCheckThreeFields
	Description:	Check three fields against the dwr object
	Changes:		
	Mark Dunlop		Created		17/08/2007
**********************************************************************/
function kainos_dwrCheckThreeFields(objectName, fieldToCheckName1, fieldToCheckName2
, fieldToCheckName3)
{
	var elementToCheck1 = document.getElementById(fieldToCheckName1);
	var elementToCheck2 = document.getElementById(fieldToCheckName2);
	var elementToCheck3 = document.getElementById(fieldToCheckName3);
	if (elementToCheck1 && elementToCheck2 && elementToCheck3) {
		var fieldToCheckValue = elementToCheck1.value + elementToCheck2.value + elementToCheck3.value;
		objectName.validateFieldGivenValue(fieldToCheckName, 
			fieldToCheckValue, kainos_dwrGenericResponse);
	}
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

/**********************************************************************
	Function:		kainos_focusToField
	Description:	Set the focus to the field specified
	Changes:		
	Mark Dunlop		Created		17/08/2007
**********************************************************************/
function kainos_focusToField(elementId){
	var element = document.getElementById(elementId);
	if(element){
		document.element.focus();
	}
}

/**********************************************************************
	Function:		kainos_ensureElementSelected
	Description:	Just ensure that -1 is not selected
	Changes:		
	Kevin Bushe		Created		01/08/2007
**********************************************************************/
function kainos_ensureElementSelected(elementId) {
	var element = document.getElementById(elementId);
	var labelStatus = document.getElementById(elementId + "Status");
	if (element.value == -1 ) {
		var labelElement = document.getElementById(elementId + "Label");
		kainos_addImage(labelStatus, false);
	} else {
		kainos_addImage(labelStatus, true);
	}
	
	var rowElem = document.getElementById(elementId+".row");
	if (rowElem!=null) {
		if (rowElem.className == ACTIVE_LONG_CLASS) {
			rowElem.className = INACTIVE_LONG_CLASS;
		}
		else {
			rowElem.className = "";
		}
	}	
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

/**********************************************************************
	Function:		kainos_ensureRadioSelected
	Description:	Just ensure that we have selected one of the 
	                elements in a radio button group. This involves
	                working out the name of the other element so radio
	                button pairs must both have the same id except the
	                last 4 chars, one of which must have Rad1 and the 
	                other rad2. This method assumes this.
	                Rad... must be used as some radios are dynamically 
	                with an index number on the name.
	Changes:		
	Mark Dunlop		Created		10/09/2008
**********************************************************************/
function kainos_ensureRadioSelected(elementName) {
	var arrayOfRadios = document.getElementsByName(elementName);
	var valid=false;
	
	for(var i=0;i<arrayOfRadios.length;i++) {
		if(arrayOfRadios[i].checked){
			valid=true;
		}
	}
	
	var labelStatus = document.getElementById(elementName + "Status");
	if(valid == false){
		var labelElement = document.getElementById(elementName + "Label");
		kainos_addImage(labelStatus, false);
	} else{
		kainos_addImage(labelStatus, true);
	}
	
	var rowElem = document.getElementById(elementName+".row");
	if (rowElem!=null) {
		if (rowElem.className == ACTIVE_LONG_CLASS) {
			rowElem.className = INACTIVE_LONG_CLASS;
		}
		else {
			rowElem.className = "";
		}
	}	
	
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

var dwrValidateFormPostSuccess = "";
var dwrValidateFormPostFailure = "";
var dwrVariableNames = "";

/**********************************************************************
	Function:		kainos_dwrValidateForm
	Description:	validates all the variables on a form
	Changes:		
					Kevin Bushe		Created		01/08/2007
**********************************************************************/
function kainos_dwrValidateForm(objectName, formName) 
{
    var formObj = document.getElementById(formName);
    
    var inputObjs = formObj.getElementsByTagName("input");
    var selectObjs = formObj.getElementsByTagName("select");
    var textAreaObjs = formObj.getElementsByTagName("textarea");
    var obj = null;
    var variableNames = "DUMMY";
    var variableValues = "__NULL__";
    var appendValue = false;
    
    if (inputObjs!=null) 
    {
        for (i=0; i<inputObjs.length; i++)
        {	
            obj = inputObjs[i];
	    	appendValue = false;
		    if (obj.type=="radio") {
				if (obj.checked) {
					appendValue = true;
				}
		    } else {
	    		appendValue = true;
		    }
	    	if (appendValue) {
	        	var vall = obj.value;
	        	if ((obj.name!="")&&(obj.name!=null)&&(obj.name.indexOf("xxx")==-1)) {
		            variableNames = variableNames + "::" + obj.name ;
					if (vall!=null && vall!="") {
				        variableValues = variableValues + "::" + vall ;
					} else {
		        	    variableValues = variableValues + "::__NULL__";
					} 
				}
		    }
        }
    }
    
    if (selectObjs!=null) 
    {
        for (i=0; i<selectObjs.length; i++)
        {
            obj = selectObjs[i];
            var vall = kainos_getSelectedValue(obj);
            if ((obj.name!=null)&&(obj.name!="")&&(obj.name.indexOf("xxx")==-1)) {
	            variableNames = variableNames + "::" + obj.name ;
				if (vall!=null && vall!="") {
			            variableValues = variableValues + "::" + vall ;
				} else {
			            variableValues = variableValues + "::__NULL__";
				} 
			}
        }
    }    
    
    if (textAreaObjs!=null) 
    {
        for (i=0; i<textAreaObjs.length; i++)
        {
            obj = textAreaObjs[i];
            if ((obj.name!=null)&&(obj.name!="")&&(obj.name.indexOf("xxx")==-1)) {
	            var vall = obj.value;   
    	        variableNames = variableNames + "::" + obj.name ;
				if (vall!=null && vall!="") {
		    	        variableValues = variableValues + "::" + vall ;
				} else {
		            variableValues = variableValues + "::__NULL__";
		        }
			} 
        }
    }    
    dwrVariableNames = variableNames;
    objectName.validateCompleteObject(variableNames, variableValues, kainos_dwrValidateFormResponse);
}

/**********************************************************************
	Function:		kainos_getSelectedValue
	Description:	Get the selected value(s) given a HTML select object
	Changes:		
					Kevin Bushe		Created		01/08/2007
**********************************************************************/
function kainos_getSelectedValue(selectObj) 
{
	var retVal = null;
	// Go through the select object
	for(var i=0;i<selectObj.length;i++) {
		// if this element is selected
		if (selectObj.options[i].selected) {
			// add it to the selected elements
			if (retVal==null) {
				retVal = selectObj.options[i].value;
			} else {
				retVal = retVal + ",," + selectObj.options[i].value;
			}
		}
	}
	return retVal;
}

/**********************************************************************
	Function:		kainos_dwrValidateFormResponse
	Description:	handles the response when a form is validated
	Changes:		
					Kevin Bushe		Created		01/08/2007
**********************************************************************/
var kainos_dwrValidateFormResponse = function(data)
{
	  if (data != null && typeof data == 'object')  {
      	alert(dwr.util.toDescriptiveString(data, 2));
      }
      else  {
      	var str = data;
      	var focus = true;
      	// if errors have been returned
      	var globalError = false;
      	var anyErrors = false;
      	
      	
      	if (str.startsWith(";;")) {
      		
      		// ok an error has occurred
      		anyErrors = true;
      		var newStr = str.substring(2, str.length);
      		var strings = newStr.split(";;");
      		// Go through the list of variables with errors
      		for(var i=0;i<strings.length;i++) {
      			var vals = strings[i].split("::");
      			
				if (vals[0]=="DEFAULT") {
					kainos_showErrorGlobal(vals[1]);
					globalError = true;
				}      			
     			if (globalError==false) {
      				kainos_showErrorRegardless(vals[0], vals[1]);
      			}
	      	}
      		var tempEval = dwrValidateFormPostFailure;
      		dwrValidateFormPostFailure = "";
      		eval(tempEval);
      	} else {
      		//alert("Gets here");
      		// If the call was successful and there is a post successful action
      		// call the action using eval
      		if (dwrValidateFormPostSuccess && dwrValidateFormPostSuccess!="") {
      			var tempEval = dwrValidateFormPostSuccess;
      			dwrValidateFormPostSuccess = "";
      			eval(tempEval);
      		}
      	}
      }
      //Now we need to loop through and set any valid fields to have a tick
      //but only if we have any validation failures
      if(anyErrors==true){
      	var fields = dwrVariableNames.split("::");
      
      	//First one is "DUMMY" so make sure we skip this
     	 for(var i=1;i<fields.length;i++){
     	 	var iconId = fields[i] + "Status";
			var icon = document.getElementById(iconId);	
			var fieldId = fields[i];
			var field = document.getElementById(fieldId);
			//required for radios
			var fieldId1 = fields[i] + "1";
			var field1 = document.getElementById(fieldId1);		
			var fieldId2 = fields[i] + "2";
			var field2 = document.getElementById(fieldId2);			

			//Only show the tick icon if the icon is not already 
			//the red x icon and the element is not hidden but 
			//there are other errors
			if ((icon!=null) && 
				(icon.innerHTML.indexOf("close") == -1) &&
				(((field!=null) && (field.value != -1) && (field.value != "")) || (field1!=null) || (field2!=null))){
				kainos_addImageLeaveError(icon, true);
			}
     	 }
      }
           
      // always reset the validate form post success field...
      // and the variable names...
      dwrValidateFormPostSuccess = "";
      dwrVariableNames = "";
}

// return the value of the radio button that is checked
// return an empty string if none are checked, or
// there are no radio buttons
function kainos_getCheckedValue(radioObj) {
	if(!radioObj)
		return "";
	var radioLength = radioObj.length;
	if(radioLength == undefined)
		if(radioObj.checked)
			return radioObj.value;
		else
			return "";
	for(var i = 0; i < radioLength; i++) {
		if(radioObj[i].checked) {
			return radioObj[i].value;
		}
	}
	return "";
}


/**********************************************************************
	Function:		kainos_singleCheckBoxChecked
	Description:	Single checkboxes must simply be checked
	Changes:		
	Mark Dunlop		Created		11/09/2008
**********************************************************************/
function kainos_singleCheckBoxChecked(elementId){	
	var element = document.getElementById(elementId);
	var labelStatus = document.getElementById(elementId + "Status");
	if (element.checked) {
		kainos_addImage(labelStatus, true);
	} else {
		var labelElement = document.getElementById(elementId + "Label");
		kainos_addImage(labelStatus, false);	
	}
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

/**********************************************************************
	Function:		kainos_alwaysValid
	Description:	Some selects have no invalid option so as soon as
	                you focus on them they cant be invalid.
	Changes:		
	Mark Dunlop		Created		11/09/2008
**********************************************************************/
function kainos_alwaysValid(elementId){	
	var labelStatus = document.getElementById(elementId + "Status");
	kainos_addImage(labelStatus, true);
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

/**********************************************************************
	Function:		kainos_validateNonNullText
	Description:	DDL texts are wiped if the entered text does not 
					match so we only have to validate that they are
					not null
	Changes:		
	Mark Dunlop		Created		16/09/2008
**********************************************************************/
function kainos_validateNonNullText(elementId){	
	var element = document.getElementById(elementId);
	var labelStatus = document.getElementById(elementId + "Status");
	
	if((element!=null) && (labelStatus!=null)){
		if(element.value == ''){
			var labelElement = document.getElementById(elementId + "Label");			
			kainos_addImage(labelStatus, false);
		}else{
			kainos_addImage(labelStatus, true);
		}
	}
	//we are bluring out of this element when this function is called 
	//so clear the help text
	kainos_hideHelp();
}

/**********************************************************************
	Function:		kainos_handleClaimFunctionalityAndValidation
	Description:	Combining the claim functionality with its 
	                validation in one call
	Changes:		
	Mark Dunlop		Created		10/09/2008
**********************************************************************/
function kainos_handleClaimFunctionalityAndValidation(elementName, count, maxsize, elementId){	
	kainos_ensureElementSelected(elementId);
	kainos_showFirstCountElementsInList(elementName, count, maxsize)
}

/**********************************************************************
	Function:		kainos_showHelp
	Description:	Displays the relevent help text in the message box
					on focus of the element
	Changes:		
	Mark Dunlop		Created		15/09/2008
**********************************************************************/
function kainos_showHelp(elementHelpTextSpan){
	var helpTextSpan = document.getElementById(elementHelpTextSpan);
	if (helpTextSpan!=null) {
		var helpElement = document.getElementById('help-box');
		if (helpElement) {
			helpElement.innerHTML = 
				"<img src=\"" + ICON_HELP_SRC + "\" />" + " " + helpTextSpan.innerHTML;
			helpElement.style.display='block';
		}
		
	}
}

/**********************************************************************
	Function:		kainos_hideHelp
	Description:	Hide the help text currently shown. This needs to
					be used on blur of all the fields
	Changes:		
	Mark Dunlop		Created		16/09/2008
**********************************************************************/
function kainos_hideHelp(){
	var helpElement = document.getElementById('help-box');
	if (helpElement) {
		helpElement.style.display='none';
	}
}

/**********************************************************************
	Function:		kainos_showError
	Description:	Displays the relevent error text in the message box
					on focus of the error icon
	Changes:		
	Mark Dunlop		Created		16/09/2008
**********************************************************************/
function kainos_showError(elementErrorTextSpan){
	var errorTextSpan = document.getElementById(elementErrorTextSpan);
	var iconId = elementErrorTextSpan.replace(".incorrect", "Status");
	var icon = document.getElementById(iconId);	
	
	//Only show the error text if the icon is the red x icon
	if ((errorTextSpan!=null) && (icon!=null) && (icon.innerHTML.indexOf("tick") == -1)){
		errorElement = document.getElementById('error-box');
		if (errorElement) {
			errorElement.innerHTML = 
				"<img src=\"" + ICON_ERROR_SRC + "\" />" + errorTextSpan.innerHTML;
			errorElement.style.display='block';
		} 
	}
}

/**********************************************************************
	Function:		kainos_showLowHighError
	Description:	Displays the relevent error text in the message box
					on focus of the error icon. This version of the 
					function shows an error with a low or high value 
					depending on other logic.
	Changes:		
	Mark Dunlop		Created		03/11/2008
**********************************************************************/
function kainos_showLowHighError(elementErrorTextSpan){
	var coverType = document.getElementById('coverTypeId').value;
	if(coverType == '1')
	{
		var errorTextSpan = document.getElementById(elementErrorTextSpan + "High");
	}
	else if(coverType != '6')
	{
		var errorTextSpan = document.getElementById(elementErrorTextSpan + "Low");
	}
	else
	{
		var errorTextSpan = document.getElementById(elementErrorTextSpan);
	}
	var iconId = elementErrorTextSpan.replace(".incorrect", "Status");
	var icon = document.getElementById(iconId);	
	
	//Only show the error text if the icon is the red x icon
	if ((errorTextSpan!=null) && (icon!=null) && (icon.innerHTML.indexOf("tick") == -1)){
		errorElement = document.getElementById('error-box');
		errorElement.innerHTML = 
			"<img src=\"" + ICON_ERROR_SRC + "\" />" + errorTextSpan.innerHTML;
		errorElement.style.display='block';
	}
}

/**********************************************************************
	Function:		kainos_showCrossValError
	Description:	Displays the relevent cross validation error text 
					in the message box on focus of the error icon
	Changes:		
	Mark Dunlop		Created		09/10/2008
**********************************************************************/
function kainos_showCrossValError(elementErrorTextSpan){
	var errorTextSpan = document.getElementById(elementErrorTextSpan);
	var iconId = elementErrorTextSpan.replace(".crossValError", "Status");
	var icon = document.getElementById(iconId);	
	
	//Only show the error text if the icon is the red x icon
	if ((errorTextSpan!=null) && (icon!=null) && (icon.innerHTML.indexOf("tick") == -1)){
		
		var errorElement = document.getElementById('error-box');
		errorElement.innerHTML = 
			"<img src=\"" + ICON_ERROR_SRC + "\" />" + errorTextSpan.innerHTML;
		errorElement.style.display='block';
	}
}

/**********************************************************************
	Function:		kainos_showErrorRegardless
	Description:	Displays the relevent error text in the message box
					on focus of the error icon
	Changes:		
	Mark Dunlop		Created		16/09/2008
	Mark Dunlop		Expanded    28/10/2008
					Because of the way the payment screen has been implemented
					there are lots of hidden fields that are actually validated 
					hence this attempts to put the red x beside them instead 
					of the actual item on the screen. quite a lot of logic
					has been added below to work around this. 
**********************************************************************/
function kainos_showErrorRegardless(elementInError, errorMessage){
  
	var adjustedErrorImgElem = "empty";
	var paymentHiddenFields = 'paymentDetails.ddPreferredBillingDayId,paymentDetails.ddAccountHolderName,paymentDetails.ddBankAccountNumber,paymentDetails.ddBankSortCode,paymentDetails.ddAmount,paymentDetails.ccAmountDeducted,paymentDetails.ccCardHolderName,paymentDetails.ccExpiryMonth,paymentDetails.ccExpiryYear,paymentDetails.ccCardNumber,paymentDetails.ccCardTypeId,paymentDetails.ccCCVNo';
								
	var splitPaymentFields = paymentHiddenFields.split(",");
	var paymentType = document.getElementById('sectionToValidate');
	if(paymentType != null){
		for(var i=0; i<splitPaymentFields.length; i++){
			if(elementInError == splitPaymentFields[i]){
				if(paymentType.value == "2"){
					adjustedErrorImgElem = elementInError.replace('paymentDetails.', 'directDebit_');
				}
				else if(paymentType.value == "3"){
					adjustedErrorImgElem = elementInError.replace('paymentDetails.', 'laserDebit_');
				}
				else if(paymentType.value == "4"){
					 adjustedErrorImgElem = elementInError.replace('paymentDetails.', 'creditCard_');
				}
			}
		}
	}			
	
	if(adjustedErrorImgElem == "empty"){
		var errorImgElem = document.getElementById(elementInError+"Status");
	}
	else{
		var errorImgElem = document.getElementById(adjustedErrorImgElem+"Status");
	}

	if (errorImgElem) { 
		kainos_addImage(errorImgElem, false);
	}

	var errorTextSpan = document.getElementById(elementInError+".incorrect");
	var errorElement = document.getElementById('error-box');
	if ((errorTextSpan) &&(errorElement)) {
		errorElement.innerHTML = 
			"<img src=\"" + ICON_ERROR_SRC + "\" />" + errorTextSpan.innerHTML; 
	}
	if (errorMessage != undefined) {
		errorElement.innerHTML = 
			"<img src=\"" + ICON_ERROR_SRC + "\" />" + errorMessage;
	}
	errorElement.style.display='block';
}

function kainos_hideErrorIcon(elementInError){
	var errorImgElem = document.getElementById(elementInError+"Status");
	if (errorImgElem) { 
		errorImgElem.innerHTML = "";
	}
	
}

/**********************************************************************
	Function:		kainos_showErrorGlobal
	Description:	Displays the relevent error text in the message box
	Changes:		
	Mark Dunlop		Created		16/09/2008
**********************************************************************/
function kainos_showErrorGlobal(textToShow){
	var errorElement = document.getElementById('error-box');
	if (errorElement) {
		errorElement.innerHTML = 
			"<img src=\"" + ICON_ERROR_SRC + "\" />" + " " + textToShow; 
	}
	errorElement.style.display='block';
}

/**********************************************************************
	Function:		kainos_showHelpGlobal
	Description:	Displays the relevent help text in the message box
	Changes:		
	Heather Campbell		Created		31/10/2008
**********************************************************************/
function kainos_showHelpGlobal(textToShow){
	var helpElement = document.getElementById('help-box');
	if (helpElement) {
		helpElement.innerHTML = 
			"<img src=\"" + ICON_HELP_SRC + "\" />" + " "  + textToShow; 
	}
	helpElement.style.display='block';
}

/**********************************************************************
	Function:		kainos_clearErrorRegardless
	Description:	Clears the relevent error text in the message box
					on focus of the error icon
	Changes:		
	Kevin Bushe		Created		16/09/2008
	Mark Dunlop		Changed		29/10/2008
					This now has a boolean parameter to decide if we 
					should replace the x with a tick or not.
**********************************************************************/
function kainos_clearErrorRegardless(elementInError, replaceWithTick){
	var errorImgElem = document.getElementById(elementInError+"Status");
	if (errorImgElem){
		if(replaceWithTick) { 
			kainos_addImage(errorImgElem, true);
		}
		else{
			errorImgElem.innerHTML = "";
		}
	}

	var errorElement = document.getElementById('error-box');
	if (errorElement) {
		errorElement.style.display='none';
	}
}

/**********************************************************************
	Function:		kainos_hideError
	Description:	Hide the error text currently shown. 
	Changes:		
	Mark Dunlop		Created		16/09/2008
**********************************************************************/
function kainos_hideError(){
	var errorElement = document.getElementById('error-box');
	errorElement.style.display='none';
	
}


function kainos_addImage(imageElement, success, text) {
	if (success) {
		var errorElement = document.getElementById('error-box');
		if (errorElement) {
			errorElement.style.display='none';
		}
		
		imageElement.innerHTML = "<img src=\"" + ICON_TICK_SRC + "\" />";
	} else {
		if (text) {
			imageElement.innerHTML = "<img src=\"" + ICON_ERROR_SRC + "\" />" + text;
		} else {
			imageElement.innerHTML = "<img src=\"" + ICON_ERROR_SRC + "\" />";
		}
	}
}

function kainos_addImageAndText(imageElement, success) {
	if (success) {
		var errorElement = document.getElementById('error-box');
		if (errorElement) {
			errorElement.style.display='none';
		}
		imageElement.innerHTML = "<img src=\"" + ICON_TICK_SRC + "\" />";
	} else {
		imageElement.innerHTML = "<img src=\"" + ICON_ERROR_SRC + "\" />";
	}
}


function kainos_addImageLeaveError(imageElement, success) {
	if (success) {
		imageElement.innerHTML = "<img src=\"" + ICON_TICK_SRC + "\" />";
	} else {
		imageElement.innerHTML = "<img src=\"" + ICON_ERROR_SRC + "\" />";
	}
}

/**********************************************************************
	Function:		kainos_dwrGenericResponse
	Description:	for single field validation the generic response
	Changes:		
	Kevin Bushe		Created		01/08/2007 q	
**********************************************************************/
var kainos_dwrGenericResponse = function(data)
{
      if (data != null && typeof data == 'object')  {
      	alert(dwr.util.toDescriptiveString(data, 2));
      }
      else  {
      	var str = data;
      	var arr = str.split("::");
      	var fieldName = arr[0];
      	var fieldValue = "";

      	if (arr.length > 1 ) {
      		fieldValue = arr[1].trim();
      	}
    	var labelStatus = document.getElementById(fieldName + "Status");
    	
      	if (fieldValue!="") {
      		if (useReturnedText=="true") {
      			kainos_showErrorGlobal(fieldValue);
      			useReturnedText = "false";
      		}
      		
      		if (labelStatus ) {
      			if (document.getElementById("error-box")) {
      				kainos_addImage(labelStatus, false);
      			} else {
      				kainos_addImage(labelStatus, false, fieldValue);
      			}
      		}
      		var errorExceptionElement = document.getElementById('ErrorException');
	      	var errorException = errorExceptionElement;
	      	if (errorException) {
	      		//alert(fieldValue);
			/*
		      	var elems = errorException.getElementsByTagName("div");
    		  	if (elems == null  || elems.length == 0 ) {
				kainos_createNewErrorBox(errorException, fieldName, fieldValue);
	      		} else {
		      		kainos_updateErrorBox(fieldName, fieldValue);
		      	}
			*/
		    } else {
		    	window.status = "Error exception section not set on page!";
		    }
      	} else {
      		kainos_addImage(labelStatus, true);
		/*
      		kainos_clearError(fieldName);
		*/
      	}
      }
}

//
// Sets attribute of given element
//
// Author Lukasz Budnik
//

function kainos_setAttribute(el, name, value) {
	for (var i = 0; i < el.attributes.length; i++) {
		if (el.attributes[i].name == name) {
			el.attributes[i].value = value;
			return;
		}
	}
	el.setAttribute(name, value);

}

if (!window.Node) var Node =
    {
      ELEMENT_NODE                :  1,
      ATTRIBUTE_NODE              :  2,
      TEXT_NODE                   :  3,
      CDATA_SECTION_NODE          :  4,
      ENTITY_REFERENCE_NODE       :  5,
      ENTITY_NODE                 :  6,
      PROCESSING_INSTRUCTION_NODE :  7,
      COMMENT_NODE                :  8,
      DOCUMENT_NODE               :  9,
      DOCUMENT_TYPE_NODE          : 10,
      DOCUMENT_FRAGMENT_NODE      : 11,
      NOTATION_NODE               : 12
    }

function kainos_simpleReplace(str, simpleReplaceText, withValueText) {
	eval("str = str.replace(/" + simpleReplaceText + "/g,\"" +withValueText + "\");");
	return str;
}

function kainos_arrayReplace(str, replaceTextArr, valueToReplaceWithTextArr) {
	var retVal = new String(str);
	var pre = retVal;
	for(var i=0;i<replaceTextArr.length;i++) {
		retVal = kainos_simpleReplace(retVal, replaceTextArr[i], valueToReplaceWithTextArr[i]);
			
	}
	if(pre.indexOf("xxx")!=-1 && pre==retVal) { 
		//alert(pre + " " + retVal);
	}
	return retVal;
}

function kainos_createElement(type, name, className) {
	var element = null;
	if ((name!=null )&&(name!="null")&&(name!="")) {
		try {
			element = document.createElement("<"+ type  + " name=\"" + name + "\" class=\"" + className + "\" />");
			element.className=className;
		} catch (e) {
		}
	}
	if (!element) {
		element = document.createElement(type);
		if ((name!=null )&&(name!="null")&&(name!="")) {
			element.name = name;
			element.className = className;
		}
	}
	return element;
}

/**********************************************************************
	Function:		kainos_replaceRecursive
	Description:	replaces all attribute/element values according to the array of values
	Changes:		
	Kevin Bushe		Created		01/08/2007 
**********************************************************************/
function kainos_replaceRecursive(obj, replaceTextArr, valueToReplaceWithTextArr) {
	// translate all the attributes
	//var obj = objOld.cloneNode();

	var newObj = kainos_createElement(obj.nodeName, 
		kainos_arrayReplace(obj.getAttribute("name"), replaceTextArr,valueToReplaceWithTextArr), 
		kainos_arrayReplace(obj.className, replaceTextArr,valueToReplaceWithTextArr));
	//newObj.className = obj.className;
	var attrib = null;
	var attributes = obj.attributes;
	var arrayNames = new Array();
	var arrayValues = new Array();
	var count = 0;
	for (var j=0;j<obj.attributes.length; j++) {
		attrib = obj.attributes[j];
		
		if ((attrib.value)&&(attrib.value != null)&&(attrib.value != "null")&&  (attrib.value != "")&&
			(attrib.value != "false")&&(attrib.value != "0")) {
		//&&  (attrib.value != "")&&(attrib.value != "false")&&(attrib.value != "0")) {

			var value = kainos_arrayReplace(attrib.value, replaceTextArr,valueToReplaceWithTextArr);
			
			if ((attrib.name!="name")&&(attrib.name!="NAME")) {	
				newObj.setAttribute(attrib.name, value);
			}

		}
	}

	// translate all the children	
	var children=obj.childNodes;
	var nd;
	for(var i=0;i<children.length;i++) {
		nd = children[i];
		if (nd.nodeType) {
		switch(nd.nodeType) {
			case Node.ELEMENT_NODE:
				var el = kainos_replaceRecursive(nd, replaceTextArr,valueToReplaceWithTextArr);	
				newObj.appendChild(el);
				//children[i] = el;
				break;
			case Node.ATTRIBUTE_NODE:
				//alert(nd.nodeType);
				nd.innerHTML = kainos_arrayReplace(nd.nodeValue, replaceTextArr,valueToReplaceWithTextArr);		
				break;
			case Node.TEXT_NODE:
				newObj.appendChild(document.createTextNode(kainos_arrayReplace(nd.nodeValue, replaceTextArr,valueToReplaceWithTextArr)));
				nd.nodeValue = kainos_arrayReplace(nd.nodeValue, replaceTextArr,valueToReplaceWithTextArr);		
				break;
			default:
				//alert(nd.nodeType);
				break;
		}
		}
	}
	return newObj;
}

function kainos_getNumberOfLevelUpsells(lvl) {
	return kainos_getGenericUpsells(lvl, "topLevelHomeUpsells", "homeUpsellDetails");
}

function kainos_getGenericUpsells(lvl, firstPart, secondPart) {
	var i = 0;
	var notFound = false;
	while (notFound == false) {
		var elem = document.getElementById(firstPart + "[" + lvl + "]."+ secondPart + "[" + i +  "].deleted");
		if (elem==null) {
			notFound = true;
		} else {
			i = i + 1;
		}
	}
	return i;
}

function kainos_getNumberOfLevelUpsellsNotDeleted(lvl) {
	return kainos_getGenericUpsellsNotDeleted(lvl, "topLevelHomeUpsells", "homeUpsellDetails");
}

function kainos_getNumberOutsideHomeUpsellsNotDeleted(lvl) {
	return kainos_getGenericUpsellsNotDeleted(lvl, "outsideHomeUpsells", "homeUpsellDetails");
}

function kainos_getGenericUpsellsNotDeleted(lvl,firstPart,secondPart) {
	var i = 0;
	var count = 0;
	var notFound = false;
	while (notFound == false) {
		var elem = document.getElementById(firstPart + "[" + lvl + "]."+ secondPart+"[" + i +  "].deleted");
		if (elem==null) {
			notFound = true;
		} else {
			var testVal = "" + elem.value;
			if (testVal=="false") {
				count = count+1;
			}
			i = i + 1;
		}
	}
	return count;
}

function kainos_simpleParseNumber(num) {
	for(var i=0;i<num.length;i++ )
	{
		if (((num.charAt(i)<'0')||(num.charAt(i)>'9')) &&
			 (num.charAt(i) != ',')) {
			return false;
		}
	}
	 var reg = new RegExp(/^\d{1,8}/);
	return reg.test(num);
}

/****************************************************************
	Function:		kainos_stripCommas
	Description:	Strip commas from monetary values
	Changes:		
	Mark Dunlop		Created 07/10/2008		
*****************************************************************/
function kainos_stripCommas(num)
{	
	var re = /,/g;
    return num.replace(re,"");
}

/****************************************************************
	Function:		kainos_policyConditions
	Description:	display or hide replumbed question based on
					when the house was built
	Changes:		
					Created		
*****************************************************************/
function kainos_policyConditions(selectId, elemId, nextOtherId) {
	var selectValue = document.getElementById(selectId).value	;
	var row = document.getElementById("homePolicyConditions.hasHouseBeenRewiredPlumbedInlast30Years.row");
	row.style.width="100%";
	var rowElem = document.getElementById(elemId+"RadioTrue");
	var nextOtherElem = document.getElementById(nextOtherId);

	if ((selectValue == "2")) {
		jQuery(row).slideDown("slow", function(){});
	} else {
		jQuery(row).slideUp("slow", function(){});
	}
}

//
// Adds new high value content	
//
function kainos_tip(text) {
}


function kainos_submitIgnoreMandatory(validator, postingAction, formName) {
	var elem = document.getElementById("ignoreMandatoryChecks");
	if(elem) {
		elem.value="true";
	}
	kainos_submit(validator, postingAction, formName);
	if(elem) {
		elem.value="";
	}	
}

function kainos_submit(validator, postingAction, formName) {
	dwrValidateFormPostSuccess = "kainos_postSuccessfulSubmit('"+formName +"','"+postingAction +"')";
	kainos_dwrValidateForm(validator, formName) 
}

function kainos_postSuccessfulSubmit(kainos_formName, postingAction) {	
	dwrValidateFormPostSuccess = "";
	/*
	 * create a submit button dynamically and assign 
	 * Spring event to it and trigger click event
	 */
	var form = document.getElementById(kainos_formName, postingAction);
	var actionButton = document.createElement('input');	
	actionButton.type = 'submit';
	actionButton.style.display = 'none';
	actionButton.name = '_eventId_' + postingAction;

	form.appendChild(actionButton);
	
	actionButton.click();
}

function kainos_setHiddenFieldGivenId(fieldId, fieldValue) {
	var elem=document.getElementById(fieldId);
	if(elem) {
		elem.value = fieldValue;
	}
}

function kainos_numberRound(val) {
	var str  = "" +  Math.round(val * 100)/100;
	var i = str.indexOf(".");
	if (i<0) {
		str = str + ".00";
		i = str.indexOf(".");
	}
	var t = str.substring(0,i+1) + str.substring(i+1, i+3);
	if (i+2 == str.length) { t = t + "0"; }
	
	return t;
}

var retrieveOccupationCallback = "";

function kainos_retrieveOccupationIdGivenOccupationName(dwrObject, fieldDescriptionId, fieldId) {
	var descElem = document.getElementById(fieldDescriptionId);
	if (descElem) {
		retrieveOccupationCallback="kainos_setHiddenFieldGivenId('" + fieldId + "','X1')";
		dwrObject.retrieveOccupationIdFromOccupationDescription(descElem.value, kainos_getDwrOccupationResult);
	}
}

var kainos_getDwrOccupationResult = function (data) {
      if (data != null && typeof data == 'object')  {
      	alert(dwr.util.toDescriptiveString(data, 2));
      }
      else  {
	      var str = data;
	      var output = retrieveOccupationCallback.replace('X1', str);
		eval(output);
      }
}

function kainos_showAssumptions() {
	if (document.getElementById('coverTypeId').selectedIndex > 0) {
		window.open('index.htm?_flowId=assumptions-flow&type=' + document.getElementById('coverTypeId').value, 'assumptions', 'menubar=no, toolbar=no, location=no, scrollbars=no, resizable=no, status=no, width=750, height=800');
	} else {
		alert('Please select Cover Type first to see assumptions and conditions');
	}
	return false;
}

function kainos_openPrintScreen(flowKey) {
	window.open('index.htm?_flowExecutionKey=' + flowKey + '&_eventId_printScreen', 'printScreen', 'menubar=no, toolbar=no, location=no, scrollbars=no, resizable=no, status=no, width=668, height=800');
	//window.open('index.htm?_flowExecutionKey=' + flowKey + '&_eventId_printScreen', 'printScreen', 'menubar=yes, toolbar=yes, location=yes, scrollbars=yes, resizable=yes, status=yes, width=668, height=800');
}

/**********************************************************************
	Function:		kainos_displayEditField
	Description:	Display edit for old screen and hide edit for new
					screen
	Changes:		
	Heather Cmapbell	Created		15/10/2008
**********************************************************************/
function kainos_displayEditField(oldScreen,newScreen)
{
    //alert("Screens: " + newScreen + " " + oldScreen);
	//first display the new edit
	var oldScreenElem = document.getElementById(oldScreen+"Edit");
	if (oldScreenElem) {
	    kainos_setShowElement(oldScreenElem);
	}
	//next hide the old edit
	var newScreenElem = document.getElementById(newScreen+"Edit");
	if (newScreenElem) {
	    kainos_setHideElement(newScreenElem);
	}
}