function show(item){ if (typeof(item) == 'string') item = document.getElementById(item); item.style.visibility = 'visible'; }
function hide(item){ if (typeof(item) == 'string') item = document.getElementById(item); item.style.visibility = 'hidden'; }
function insert(item){ if (typeof(item) == 'string') item = document.getElementById(item); item.style.display = 'inline'; }
function remove(item){ if (typeof(item) == 'string') item = document.getElementById(item); item.style.display = 'none'; }

function mouseover(s) { s.getElementsByTagName("img")[0].src = s.getElementsByTagName("img")[0].src.replace(/rolloff/, "rollon"); }
function mouseout(s) { s.getElementsByTagName("img")[0].src = s.getElementsByTagName("img")[0].src.replace(/rollon/, "rolloff"); }
function divmouseover(s) { s.className = s.className.replace(/rolloff/, "rollon"); }
function divmouseout(s) { s.className = s.className.replace(/rollon/, "rolloff"); }

function contact(f) {
	validated=false;

	if (f.fn.value == '') {
		alert(EMPTYFIRSTNAME);
		f.fn.focus();
	} else if (f.ln.value == '') {
		alert(EMPTYLASTNAME);
		f.ln.focus();
	} else if (f.from.value == '') {
		alert(EMPTYEMAIL);
		f.from.focus();
	} else if (!isEmailValid(f.from.value)) {
		alert(WRONGEMAILFORMAT);
		f.from.focus();
	} else if (f.phone.value == '') {
		alert(EMPTYPHONENUMBER);
		f.phone.focus();
	} else if (f.Body.value.length == 0) {
		alert(EMPTYMESSAGE);
		f.Body.focus();
	} else {
		f.Cc.value = f.from.value;
		validated=true;
	}

	return validated;
}
// ----------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
// Fonction EmailValide
// Semantique : vérifie si l'adresse email est valide
// Parametres : l'adresse email
/////////////////////////////////////////////////////////////////////////////
function isEmailValid (email)
{
// jean-christophe.dupont-machin@truc-bidule.boite.com.bz
return /^\w+([\.\-]?\w+)*@\w+([\.\-]?\w+)*(\.\w{2,3})+$/.test(email);
} // EmailValide


/////////////////////////////////////////////////////////////////////////////
// Fonction LienValide
// Semantique : vérifie si le lien est valide
// Parametres : le lien
/////////////////////////////////////////////////////////////////////////////
function isLinkValid (lien)
{
// http://www.machin.machin-fr.com/machin/machin.html
return /^(http:\/\/)?(www.)?[\.\-\?=&_\/\d\w]+$/.test(lien);
} // LienValide

/////////////////////////////////////////////////////////////////////////////
// Fonction TelephoneValide
// Semantique : vérifie si le téléphone est valide
// Parametres : le téléphone
/////////////////////////////////////////////////////////////////////////////
function isPhoneValid (telephone)
{
// (33)05610946
// /^(\(\d\d\()?(\d\s)*$/
return /^(\(\d\d\))?(\d\s?\.?)*$/.test(telephone);
} // TelephoneValide


function enlarge(a) {
	window.open(a.childNodes.item(0).src,'photoZoom','"location=0,status=0,scrollbars=1')
}


function validateForm(submitIfOk, formname) {

	if (submitIfOk == undefined) submitIfOk = true;
	var myForm = (formname == undefined ? document.forms[0] : document.getElementById(formname));
	var elem = myForm.elements;
	var s = elem.length

	for(i=0; i<s; i++) {
		var field = elem[i];
		if (field.getAttribute('type') == undefined) continue;
		v = getInputFieldValue(field);

		// --- step 1: check if mandatory field is filled
		if (v== '' && field.getAttribute('mandatory') != undefined) {
			alert ('This field should be filled: '+field.name);
			field.focus();
			return (false);
		}

		// --- step 2: check if filled field value is consistent with expected format
		if (v != '' && field.getAttribute('format') != undefined) {
			switch (field.getAttribute('format')) {
				case 'email':
					if (!isEmailValid(v)) {
						alert ('Wrong email format: '+field.name);
						field.focus();
						return false;
					}
					break;
				case 'upperTextOnly':
					if (!isUpperTextOnlyValid(v)) {
						alert ('This field should be in uppercased text format: '+field.name);
						field.focus();
						return false;
					}
					break;
				case 'textOnly':
					if (!isTextOnlyValid(v)) {
						alert ('This field should be in  text format: '+field.name);
						field.focus();
						return false;
					}
					break;
				case 'time':
					if (v != 'hh:mm' && !isTimeValid(v)) {
						alert ('This field should be in time hh:mm format: '+field.name);
						field.focus();
						return (false);
					}
					break;
				case 'date':
					if (v != 'dd/mm/yyyy' && !isDateValid(v)) {
						alert ('This field should be in date dd/mm/yyyy format: '+field.name);
						field.focus();
						return false;
					}
					break;
				case 'integer':
					if (isNaN(v)) {
						alert ('This field should be an integer number: '+field.name);
						field.focus();
						return false;
					}
					break;
				case 'fk':
					v = v.toUpperCase();
					setInputFieldValue(fieldf,v);
					var info=field.getAttribute('fk').split(';');
					if (!isFkValid(v,info)) {
						alert ('This field should be a valid '+info[0]+': '+field.name);
						field.focus();
						return false;
					}
					break;
				default:
			}
		}

	}
	//alert('Finished parsing the form');
	if (submitIfOk) myForm.submit();
	return true;
}

// --- general fields management: GETTER
function getInputFieldValue(champ) {

	var type = ''; var value = ''; var name = '';

	// for radio buttons
	if (typeof (champ.type) == 'undefined') {
		type = champ[0].type.toLowerCase();
		name = champ[0].name;
	} else {
		type = champ.type.toLowerCase();
		name = champ.name;
	}
	switch (type) {
		case 'file':
		case 'textarea':
		case 'password':
		case 'hidden':
		case 'text':
			value = getTextFieldValue(champ);
			break;
		case 'select' :
		case 'select-one' :
			value = getSelectFieldValue(champ);
			break;
		case 'select-multiple':
			value = getSelectValues(champ)
			break
		case 'checkbox' :
			value = getCheckboxValues(champ);
			break;
		case 'radio' :
			// there is a bug when radio is hidden, it is of type 'undefined' in firefox
		default:
			value = getRadioFieldValue(champ);
			break;
	}

//Tracer ("(get) Type du champ: "+name+" = "+type+" "+value);
	return (typeof(value) == 'undefined' ? '' : value);
}

// --- general fields management: SETTER
function setInputFieldValue(champ, value) {
	var type = ''; var name = '';

	// for radio buttons
	if (typeof (champ.type) == 'undefined') {
		type = champ[0].type.toLowerCase();
		name = champ[0].name;
	} else {
		type = champ.type.toLowerCase();
		name = champ.name;
	}

	//Tracer ("(set) Type du champ: "+champ.name+" = "+champ.type);

	switch (type) {
		case 'file':
		case 'textarea':
		case 'password':
		case 'hidden':
		case 'text':
			setTextFieldValue(champ, value);
			break;
		case 'select' :
		case 'select-one' :
			setSelectFieldValue(champ, value);
			break;
		case 'select-multiple':
			setSelectValues(champ,value)
			break;
		case 'checkbox' :
			setCheckboxValues(champ, value);
			break;
		case 'radio' :
			// there is a bug when radio is hidden, it is of type 'undefined' in firefox
		default:
			setRadioFieldValue(champ, value);
			break;
	}
}
// ----------------------------------------------------------------------
// INPUT FIELDS MANIPULATION
// ----------------------------------------------------------------------

// --- returns the selected value of a radio button set
function getRadioFieldValue(field) {

	var radioSize = field.length;
	var value = "";
	for (var i = 0; i < radioSize; i++) {
		if (field[i].checked) value = field[i].value;
	}
	return (value);
}
// --- returns the selected value of a radio button set
function setRadioFieldValue(field, value) {

	var radioSize = field.length;
	for (var i = 0; i < radioSize; i++) {
		if (field[i].value == value) field[i].checked = true;
	}
}
function isChecked(champs) {

	if (typeof(champs.length) != 'undefined')
		return (champs[0].checked);
	else
		return (champs.checked);
}

// --- returns the selected value of a SELECT List
function getSelectedIndex(field,value) {
	var retValue = field.length;
	for (var i = retValue-1; i >= 0; i--) {
		if (field.options[i].value == value) { retValue = i; break; }
	}
	return retValue;
}
function getSelectFieldValue(field) {
	//Tracer (field.options[field.selectedIndex].value);
	return (typeof(field.options) == 'undefined' ? '' : field.options[field.selectedIndex].value);
}
function getSelectFieldLabel(field) {
	return (typeof(field.options) == 'undefined' ? '' : field.options[field.selectedIndex].text);
}
function setSelectFieldValue(field, value) {
	var size = field.options.length;
	for (var i = 0; i< size; i++) {
		if (field.options[i].value == value) { field.options[i].selected = true; break; }
	}
}

function setSelectFieldValues(field, values) {
	field.options.length = 0;
	field.length = 0;
	var size = values.length;
	// IE is dumb here... let's do it plainly
	// field.options = values is impossible
	for (var i = 0; i<size; i++) field.options[i] = values[i];

}

// --- multiple select management
function getSelectValues(champs) {
	var values = Array();
	var size = champs.length;
	for (var i=0; i< size; i++) if (champs[i].selected) values[values.length] = champs[i].value;
	return values;
}
function setSelectValues(champs, value, force) {
	// value is handled yet as a single value
	var always = false;
	var never = false;

	if (typeof(force) != undefined) {
		if (force == true) always = true; else never = true;
	}

	var size = champs.length;
	for (var i=0; i< size; i++) {
		champs[i].selected = (!never && (always || champs[i].value == value));
	}
}

// --- returns the value of a text field and applies replaces
function getTextFieldValue(field) {
	//return (typeof(field) == 'undefined' ? '' : strReplace(field.value,'"',"'"));
	return (typeof(field) == 'undefined' ? '' : Addslashes(field.value));
}
function setTextFieldValue(field, value) {
	field.value = value;
}

// --- checkboxes management
function getCheckboxValues(champs) {
	var values = Array();
	if (typeof(champs.length) != 'undefined') {
		var size = champs.length;
		for (var i=0; i< size; i++) {
			if (champs[i].checked) values[values.length] = champs[i].value;
		}
	} else
		if (champs.checked) values[0] = champs.value;
	return values;
}

function setCheckboxValues(champs, value, force) {
	var always = false;
	var never = false;
	// value is handled yet as a single value

	if (typeof(force) != undefined) {
		if (force == true) always = true; else never = true;
	}

	if (typeof(champs.length) != 'undefined') {
		var size = champs.length;
		for (var i=0; i< size; i++) {
			champs[i].checked = (!never && (always || champs[i].value == value));
		}
	} else
		champs.checked = (!never && (always || champs.value == value));
}
function checkAllBoxes(champs) {
	setCheckboxValues(champs, '', true);
}

function unCheckAllBoxes(champs) {
	setCheckboxValues(champs, '', false);
}
// ----------------------------------------------------------------------
// STRING MANIPULATION
// ----------------------------------------------------------------------

/////////////////////////////////////////////////////////////////////////////
// Fonction Addslashes
// Semantique : ajoute des slashes devant tous les ' et "
// Parametres : string : une chaine
/////////////////////////////////////////////////////////////////////////////
function Addslashes(string)
{
	var new_string = string.replace(/'/g,"\\\'");
	//new_string = new_string.replace(/"/g,"\\\"");

	return new_string;
} // Addslashes

// --- The leftTrim JavaScript function to remove left spaces from string
function leftTrim(sString) {
	while (sString.substring(0,1) == ' ') {
		sString = sString.substring(1, sString.length);
	}
	return sString;
}


// --- The rightTrim() JavaScript function to remove right spaces from string
function rightTrim(sString) {
	while (sString.substring(sString.length-1, sString.length) == ' ') {
		sString = sString.substring(0,sString.length-1);
	}
	return sString;
}

// --- strReplace: String Replace / if not found, then add !
function strReplace (txt, oldStr, newStr) {
	if (typeof (txt) == 'undefined' || txt == null) return '';
	while (txt.indexOf(oldStr) != -1)
	txt = txt.substring(0,txt.indexOf(oldStr))+newStr+txt.substring(txt.indexOf(oldStr)+oldStr.length);

	return txt;
}

function wordwrap(txt,cols) {
	if (typeof (txt) == 'undefined' || txt == null) return '&nbsp;';
	var size = txt.length;

	var pos = cols;
	while (pos <= size) {
		txt = txt.substring(0,pos) + '<br>' + txt.substring(pos);
		pos += cols;
	}

	return txt;
}

function NVL(value) {
	return (value == "" ? "''" : "'"+escape(value)+"'");
}

function html_entity_decode(text) {

	// --------------------------------------------- //
	// Remplace DANS tous les éléments de CA par PAR //
	// ca :  tableau de chaine à remplacer   [A, C]  //
	// par : tableau de chaine à remplaçante         //
	// --------------------------------------------- //
	function Remplace (dans, ca, par)
	{
		var resultat = dans;
		for (var element = 0; element < ca.length; element++)
		   {//alert ("Resultat:" + resultat + " / " + element);
		   resultat = resultat.replace (new RegExp (ca [element], "g"), par [element]);
		   //alert ("Resultat:" + resultat);
		   }

		return resultat;
	}
	// TODO: a completer
	var ca = Array ("&amp;", "&gt;", "&lt;", "&eacute;", "&egrave;", "&agrave;","&deg;");
	var par = Array ("&", ">", "<","é", "è", "à","°");

	return (Remplace (text, ca, par))
}

// --- stripSlashDot: extacts the actual file name without path and extension
function stripSlashDot (url) {
	return url.substring(url.lastIndexOf('/')+1,url.lastIndexOf('.'));
}