// ----------------------------------------------------------------------
// Javascript form validation routines.
// ----------------------------------------------------------------------

var nbsp = 160;		// non-breaking space char
var node_text = 3;	// DOM text node-type
var emptyString = /^\s*$/ ;
var global_valfield;	// retain valfield for timer thread

// --------------------------------------------
//                  trim
// Trim leading/trailing whitespace off string
// --------------------------------------------

function trim(str)
{
  return str.replace(/^\s+|\s+$/g, '');
}


// --------------------------------------------
//                  setfocus
// Delayed focus setting to get around IE bug
// --------------------------------------------

function setFocusDelayed()
{
  global_valfield.focus();
}

function setfocus(valfield)
{
  // save valfield in global variable so value retained when routine exits
  global_valfield = valfield;
  setTimeout( 'setFocusDelayed()', 100 );
}


// --------------------------------------------
//                  msg
// Display warn/error message in HTML element.
// commonCheck routine must have previously been called
// --------------------------------------------

function msg(fld,     // id of element to display message in
             msgtype, // class to give element ("warn" or "error")
             message) // string to display
{
  // setting an empty string can give problems if later set to a 
  // non-empty string, so ensure a space present. (For Mozilla and Opera one could 
  // simply use a space, but IE demands something more, like a non-breaking space.)
  var dispmessage;
  if (emptyString.test(message)) 
    dispmessage = String.fromCharCode(nbsp);    
  else  
    dispmessage = message;

  var elem = document.getElementById(fld);
  elem.firstChild.nodeValue = dispmessage;  
  
  elem.className = msgtype;   // set the CSS class to adjust appearance of message
}


// --------------------------------------------
//               validateEmail
// Validate if e-mail address
// Returns true if so (and also if could not be executed because of old browser)
// --------------------------------------------

function validateFakeCaptcha  (valfield,   // element to be validated
                         infofield,  // id of element to receive info/error msg
                         required,   // true if required
						 language,
						 fake_captcha_string)
{ //alert('validateEmail'+valfield.value+', '+infofield+', '+language);///////////////////////////////
  var stat = commonCheck (valfield, infofield, required, language);
  var errMsg = "";
  
  if (stat != proceed) return stat;
  
  var tfld = trim(valfield.value);  // value of field with whitespace trimmed off
/*  alert(tfld.toLowerCase() );
  alert(fake_captcha_string);*/
  var email = /^[^@]+@[^@.]+\.[^@]*\w\w$/  ;
  // if (!email.test(tfld)) {
  if (fake_captcha_string!=tfld.toLowerCase()) {	  
	  switch(language){
/*			case "dk":
				errMsg = "Fejl: det er ikke en gyldig e-mail adresse";
				break;
			case "no":
				errMsg = "Feil: ugyldig epost adresse";
				break;*/
			case "eng":
				errMsg = "Incorrect validation code!";
				break;
/*			case "se":
				errMsg = "Inte en godk\u00e4nd e-post adress";
				break;
			case "de":
				errMsg = "Keine g\u00fcltige";
				break;
			case "fi":
				errMsg = "Virheellinen s\u00e4hk\u00f6postiosoite";
				break;
			case "nl":
				errMsg = "Fout: Geen geldig emailadres!";
				break;
			case "fr":
				errMsg = "Erreur. L'adresse email n'est pas valide!";
				break;*/
	  	}
    msg (infofield, "error", errMsg);
    setfocus(valfield);
    return false;
  } else {
	  msg (infofield, "", "");
	  return true;
  }

/*  var email2 = /^[A-Za-z][\w.-]+@\w[\w.-]+\.[\w.-]*[A-Za-z][A-Za-z]$/  ;
  if (!email2.test(tfld)) 
    msg (infofield, "warn", "Venligst tjek e-mail adressen");
  else
    msg (infofield, "warn", "");*/
  
}

// --------------------------------------------
//            commonCheck
// Common code for all validation routines to:
// (a) check for older / less-equipped browsers
// (b) check if empty fields are required
// Returns true (validation passed), 
//         false (validation failed) or 
//         proceed (don't know yet)
// --------------------------------------------

var proceed = 2;  

function commonCheck    (valfield,   // element to be validated             
                         infofield,  // id of element to receive info/error msg
                         required,	 // true if required
						 language)   // 
{
		//alert('commonCheck: '+valfield.value+', '+infofield+', '+required+', '+language);
	var errMsg = "";
	switch(language){
		case "dk":
			errMsg = "Skal udfyldes";
			break;
		case "no":
			errMsg = "Skal utfylles";
			break;
		case "eng":
			errMsg = "Required";
			break;
		case "de":
			errMsg = "Pflichtfeld";
			break;
		case "se":
			errMsg = "Saknas";
			break;
		case "fi":
			errMsg = "Pakollinen";
			break;
		case "nl":
			errMsg = "Verplicht veld";
			break;
		case "fr":
			errMsg = "Champs obligatoire";
			break;
	}
  if (!document.getElementById) 
    return true;  // not available on this browser - leave validation to the server
  var elem = document.getElementById(infofield);
  if (!elem.firstChild) return true;  // not available on this browser 
  if (elem.firstChild.nodeType != node_text) return true;  // infofield is wrong type of node  

  if (emptyString.test(valfield.value)) {
    if (required) {
      msg (infofield, "error", errMsg);  
      setfocus(valfield);
      return false;
    }
    else {
      msg (infofield, "warn", "");   // OK
      return true;  
    }
  }
  return proceed;
}

// --------------------------------------------
//            validateSelect
// Validate if something is selected
// Returns true if so (and also if could not be executed because of old browser)
// Returns false and an error message if nothing is selected
// --------------------------------------------
							// element to be validated ,id of element to receive info/error msg, true if required
function validateSelect(valfield, infofield, required, language)
{
	var errmsg = "";
	//alert('validateSelect --> value = '+valfield.value);///////////////////////////
	
	  if(valfield.value == 0) {	
  			//alert('validateSelect --> valfield.value = '+valfield.value+', return false');////////////////////////////////////
			switch(language){
				case "dk":
					errMsg = "V&aelig;lg venligst.";
					break;
				case "no":
					errMsg = "Velg venligst.";
					break;
				case "eng":
					errMsg = "Required";
					break;
				case "de":
					errMsg = "Pflichtfeld";
					break;
				case "se":
					errMsg = "Saknas";
					break;
				case "fi":
					errMsg = "Valitse";
					break;
				case "nl":
					errMsg = "Verplicht veld";
					break;
				case "fr":
					errMsg = "Champs obligatoire";
					break;
			}
			msg (infofield, "error", errMsg);		  
			setfocus(valfield);
			return false;
		} else {	
			//alert('validateSelect --> valfield.value = '+valfield.value+', return true');//////////////////////////////////////
			msg (infofield, "warn", "");
			return true;
		}
}


// -----------------------------------------
//            validateCheckbox
// Validate that the correct number of checkboxes has been checked.
// Returns true if valid (and also if could not be executed because 
// of old browser)
// -----------------------------------------

function validateCheckbox  (vfld,   // checkboxes to be validated
                            ifld,   // id of element to receive info/error msg
                            nr,     // number of checkboxes to be checked. >=2
                            cond)   // condition: -1 = less than or equal to nr
                                    //             0 = equal to nr (default)
                                    //             1 = greater than or equal to nr
{
  if (!nr || nr<2) {
    //alert('Programming error in validateCheckbox: nr<2'); 
       // for nr=1 use radio buttons or validateCheckbox
    return true;
  }
  if (!cond) cond = 0;

  var stat = commonCheck2(vfld, ifld);
  if (stat != proceed) return stat;

  // count how many boxes have been checked by the reader
  var count = 0;
  for (var j=0; j<vfld.length; j++)
     if (vfld[j].checked) count++;

  if (count==nr) return true;
  if (count<nr && cond==-1) return true;
  if (count>nr && cond==1)  return true;

  // if we get here then the validation has failed

  var suffix='';
  if (count>1) suffix='es';

  var errorMsg;
  
  if (count!=nr) errorMsg = 'Venligst tjek alle ' + nr + '.';

/* 	// used if there are a certain number of checkboxes required

  if (count<nr) errorMsg = 'Only ' + count + ' box' + suffix + ' checked: ' + nr + ' required';
  if (count>nr) errorMsg = '' + count + ' boxes checked: maximum ' + nr + ' allowed';
  if (count==0) errorMsg = 'No boxes checked: ' + nr + ' required';
*/
  msg (ifld, "error", errorMsg);
  return false;
}


// -----------------------------------------
//            validateCheckbox 
// Usually one doesn't want to validate if 1 checkbox of a set has been
// checked, because in this case one would use radio buttons instead.
// But sometimes one wants a reader to check a single box to confirm that 
// he or she agrees to something. That is covered by this routine.
//
// Returns true if valid (and also if could not be executed because 
// of old browser)
// -----------------------------------------

function validateCheckbox   (vfld,   // checkbox to be validated
                            ifld,   // id of element to receive info/error msg
							language)
{
  var stat = commonCheck2(vfld, ifld);
  if (stat != proceed) return stat;

  if (vfld.checked) return true;

  // if we get here then the validation has failed
  var errorMsg = '';
  switch(language){
	case "dk":
		errorMsg = "Venligst marker";
		break;
	case "no":
		errorMsg = "Venligst marker";
		break;
	case "eng":
		errorMsg = "Please confirm";
		break;
	case "de":
		errorMsg = "Bitte best\u00e4tigen";
		break;
	case "se":
		errorMsg = "Saknas";
		break;
	case "fi":
		errorMsg = "Vahvista";
		break;
	case "fr":
		errorMsg = "Veuillez svp confirmer";
		break;
	case "nl":
		errorMsg = "Aub bevestigen";
		break;
	}

  setfocus(vfld);

  msg (ifld, "error", errorMsg);
  return false;
}

// -----------------------------------------
//            commonCheck2
// Common code for checkbox validation routines to
// check for older / less-equipped browsers
// Returns true (validation passed) or
//         proceed (don't know yet)
// -----------------------------------------

var proceed = 2;  

function commonCheck2   (vfld,   // element to be validated
                         ifld)   // id of element to receive info/error msg
{
  if (!document.getElementById) 
    return true;  // not available on this browser - leave validation to the server
  var elem = document.getElementById(ifld);
  if (!elem.firstChild)
    return true;  // not available on this browser 
  if (elem.firstChild.nodeType != node_text)
    return true;  // ifld is wrong type of node  

  msg (ifld, "warn", "");  // clear any previous error message
  return proceed;
}

// --------------------------------------------
//            validatePresent
// Validate if something has been entered
// Returns true if so 
// --------------------------------------------

function validatePresent(valfield,   // element to be validated
                         infofield,  // id of element to receive info/error msg
						 language)
{
	//alert('validatePresent'+valfield.value+', '+infofield+', '+language);//////////////////////////
  var stat = commonCheck (valfield, infofield, true, language);
  if (stat != proceed) return stat;

  msg (infofield, "warn", "");  
  return true;
}

// --------------------------------------------
//               validateEmail
// Validate if e-mail address
// Returns true if so (and also if could not be executed because of old browser)
// --------------------------------------------

function validateEmail  (valfield,   // element to be validated
                         infofield,  // id of element to receive info/error msg
                         required,   // true if required
						 language)
{ //alert('validateEmail'+valfield.value+', '+infofield+', '+language);///////////////////////////////
  var stat = commonCheck (valfield, infofield, required, language);
  var errMsg = "";
  
  if (stat != proceed) return stat;
  
  var tfld = trim(valfield.value);  // value of field with whitespace trimmed off
  var email = /^[^@]+@[^@.]+\.[^@]*\w\w$/  ;
  if (!email.test(tfld)) {
	  switch(language){
			case "dk":
				errMsg = "Fejl: det er ikke en gyldig e-mail adresse";
				break;
			case "no":
				errMsg = "Feil: ugyldig epost adresse";
				break;
			case "eng":
				errMsg = "Error: Not a valid email!";
				break;
			case "se":
				errMsg = "Inte en godk\u00e4nd e-post adress";
				break;
			case "de":
				errMsg = "Keine g\u00fcltige";
				break;
			case "fi":
				errMsg = "Virheellinen s\u00e4hk\u00f6postiosoite";
				break;
			case "nl":
				errMsg = "Fout: Geen geldig emailadres!";
				break;
			case "fr":
				errMsg = "Erreur. L'adresse email n'est pas valide!";
				break;
	  	}
    msg (infofield, "error", errMsg);
    setfocus(valfield);
    return false;
  }

  var email2 = /^[A-Za-z][\w.-]+@\w[\w.-]+\.[\w.-]*[A-Za-z][A-Za-z]$/  ;
  if (!email2.test(tfld)) 
    msg (infofield, "warn", "Venligst tjek e-mail adressen");
  else
    msg (infofield, "warn", "");
  return true;
}

///////////////////////////////// Sett prefiks ut fra land og sjekk kun på numerisk input
// --------------------------------------------
//            validateTelnr
// Validate telephone number
// Returns true if so (and also if could not be executed because of old browser)
// Permits spaces, hyphens, brackets and leading +
// --------------------------------------------

function validateTelnr  (valfield,   // element to be validated
                         infofield,  // id of element to receive info/error msg
                         required,   // true if required
						 language) {
	
	var stat = commonCheck (valfield, infofield, required, language);
  	var errMsg = "";
  	if (stat != proceed) return stat;
  	var tfld = trim(valfield.value);  // value of field with whitespace trimmed off	
	var numdigits = 0;
	for (var j=0; j<tfld.length; j++)
    if (tfld.charAt(j)>='0' && tfld.charAt(j)<='9') numdigits++;
	
  	var telnr = /^\+?[0-9 -]+[0-9]$/  ;
  	if (!telnr.test(tfld)) {
	  	switch(language){
			case "dk":
				errMsg = "Fejl: Telefon nummeret er ugyldig. Du kan bruge + foran tal og mellemrum.";
				break;
			case "no":
				errMsg = "Feil: Telefonnummeret er ugyldig. Du kan bruke + foran tal og mellemrum.";
				break;
			case "eng":
				errMsg = "Digit, space \u0026 lead +.";
				break;
			case "de":
				errMsg = "Nur Ziffern, Leerzeichen und + am Anfang erlaubt.";
				break;
			case "se":
				errMsg = "Endast siffror";
				break;
			case "fi":
				errMsg = "Ainostaan numerot mahdollisia";
				break;
	  	}
		msg (infofield, "error", errMsg);		  
    	setfocus(valfield);
    	return false;
  	}  

   else if (numdigits<6||numdigits>12) {
	  switch(language){
			case "dk":
				errMsg = "Fejl: Tjek antal tal i telefon nummeret";
				break;
			case "no":
				errMsg = "Sjekk antall tall i telefonnummeret";
				break;
			case "eng":
				errMsg = "Error: Please check the number of digits in the phone number.";
				break;
			case "de":
				errMsg = "Bitte \u00fcberpru\u00fcfen Sie die Anzahl der Ziffern der Telefonnummer.";
				break;
			case "se":
				errMsg = "Antal siffror.";
				break;
			case "fi":
				errMsg = "Virhe: Puhelinnumero virheellinen.";
				break;
	  	}
		msg (infofield, "error", errMsg);		  
    	setfocus(valfield);
		return false;
  }
  else { msg (infofield, "warn", "");}
  
  return true;
}

// --------------------------------------------
//            validateTelnrNoPrefix
// Validate phone number
// Returns true if so (and also if could not be executed because of old browser)
// --------------------------------------------

function validateTelnrNoPrefix(valfield,   // element to be validated
                         infofield,  // id of element to receive info/error msg
                         required,   // true if required
						 language)
{	
	var stat = commonCheck (valfield, infofield, required, language);
	var errMsg = "";
  	if (stat != proceed) return stat;
	if(!isNumeric(valfield.value) ) {		
		switch(language) {
			case "dk":
				errMsg = "Fejl: Tast kun nummer ind. Landekoden l&aelig;gges til automatisk";
				break;
			case "eng":
				errMsg = "Error: Only digits are valid. No country code required";
				break;
		}
		msg (infofield, "error", errMsg);
		setfocus(valfield);
	} else if(valfield.value.length<8 || valfield.value.length>12){
		switch(language) {
			case "dk":
				errMsg = "Fejl: tjek antal tal";
				break;
			case "eng":
				errMsg = "Error: to short phone number";
				break;
		}
		msg (infofield, "error", errMsg);
		setfocus(valfield);
	}
	else {
		msg (infofield, "warn", "");
	}	
	return true;
}


// --------------------------------------------
//             validateAge
// Validate person's age
// Returns true if OK 
// --------------------------------------------

function validateAge    (valfield,   // element to be validated
                         infofield,  // id of element to receive info/error msg
                         required)   // true if required
{
  var stat = commonCheck (valfield, infofield, required);
  if (stat != proceed) return stat;

  var tfld = trim(valfield.value);
  var ageRE = /^[0-9]{1,3}$/
  if (!ageRE.test(tfld)) {
    msg (infofield, "error", "ERROR: not a valid age");
    setfocus(valfield);
    return false;
  }

  if (tfld>=200) {
    msg (infofield, "error", "ERROR: not a valid age");
    setfocus(valfield);
    return false;
  }

  if (tfld>110) msg (infofield, "warn", "Older than 110: check correct");
  else {
    if (tfld<7) msg (infofield, "warn", "Bit young for this, aren't you?");
    else        msg (infofield, "warn", "");
  }
  return true;
}


// --------------------------------------------
//            validateZip
// Validate zip code number
// Returns true if so (and also if could not be executed because of old browser)
// Permits spaces, hyphens, brackets and leading +
// --------------------------------------------

function validateZip  (valfield,   // element to be validated
                         infofield,  // id of element to receive info/error msg
                         required,   // true if required
						 language)
{	
	var stat = commonCheck (valfield, infofield, required, language);
  	if (stat != proceed) return stat;
	if(!isNumeric(valfield.value) ) {
		switch(language) {
			case "dk":
				msg (infofield, "error", "Fejl: kun tal skal tastes ind");
			case "eng":
				msg (infofield, "error", "Error: Only digits are valid");
		}
		setfocus(valfield);
	} else {
		if(valfield.value.length < 4) {
			switch(language) {
			case "dk":
				msg (infofield, "error", "Fejl: tjek antal tal");
			case "eng":
				msg (infofield, "error", "Error: check number of digits");
			}
			setfocus(valfield);
		}
		else {msg (infofield, "warn", "");}		
	}	
	return true;
}

// --------------------------------------------
//            validateVATnr
// Validate VAT number
// Returns true if so (and also if could not be executed because of old browser)
// --------------------------------------------

function validateVATnr(valfield,   // element to be validated
                         infofield,  // id of element to receive info/error msg
                         required,   // true if required
						 language)
{	
	var stat = commonCheck (valfield, infofield, required, language);
	var errMsg = "";
  	if (stat != proceed) return stat;
	if(!isNumeric(valfield.value) ) {		
		switch(language) {
			case "dk":
				errMsg = "Fejl: kun tal skal tastes ind";
				break;
			case "no":
				errMsg = "Kun tall";
				break;
			case "se":
				errMsg = "Endast siffror";
				break;
			case "eng":
				errMsg = "Error: Only digits are valid";
				break;
		}
		
		
		msg (infofield, "error", errMsg);
		setfocus(valfield);
	} else if(valfield.value.length<4 || valfield.value.length>14){
		switch(language) {
			case "dk":
				errMsg = "Fejl: tjek antal tal";
				break;
			case "no":
				errMsg = "Sjekk antall tall";
				break;
			case "se":
				errMsg = "Antal siffror";
				break;
			case "eng":
				errMsg = "Error: to short VAT number";
				break;
		}
		msg (infofield, "error", errMsg);
		setfocus(valfield);
	}
	else {
		msg (infofield, "warn", "");
	}	
	return true;
}


// --------------------------------------------
//            isNumeric
// Validate if a string only consist of digit characters
// Returns true if so and false and an error msg if not 
// --------------------------------------------

function isNumeric(valfield) {
	
   var validChars = "0123456789"; // valid characters in the string
   var IsNumber=true;
   var Char;
   
   			// test if each character in the string are valid
   for (i = 0; i < valfield.length && IsNumber == true; i++) 
      { 
      Char = valfield.charAt(i); 
      if (validChars.indexOf(Char) == -1) {
         IsNumber = false; }
      }
   return IsNumber;   
   }
// --------------------------------------------
//            validateNumber
// Validate if a string only consist of digit characters
// Returns true if so and false and an error msg if not 
// --------------------------------------------
function validateNumber(valfield,   // element to be validated
                         infofield,  // id of element to receive info/error msg
                         required,   // true if required
						 language)
{	
//alert('validateNumber');
	var stat = commonCheck (valfield, infofield, required, language);
	//alert('stat '+stat);
	var errMsg = "";
	////alert('errMsg '+errMsg);
  	if (stat != proceed) return stat;
	//alert('proceed '+proceed);
	if(!isNumeric(valfield.value) ) {	
		//alert('isNumeric '+isNumeric(valfield.value));
		switch(language) {
			case "dk":
				errMsg = "Fejl: kun tal skal tastes ind";
				break;
			case "eng":
				errMsg = "Error: Only digits are valid";
				break;
			case "de":
				errMsg = "Nur Ziffern sind g\u00fcltig";
				break;
			case "se":
				errMsg = "Endast siffror";
				break;
			case "fi":
				errMsg = "Ainostaan numerot mahdollisia";
				break;
		}
		msg (infofield, "error", errMsg);
		setfocus(valfield);
		return false;
	}
	else {
		msg (infofield, "warn", "");
		return true;
	}
}
// --------------------------------------------
//            validateRadioGroup
// Validate if any of a group of radio buttons are checked
// Returns true if so and false and an error msg if not 
// --------------------------------------------

function validateRadioGroup(valfield, infofield, required, language){
	radio_value = get_radio_value(valfield);
	//alert('radio value' + radio_value);
	if (radio_value == false) {
		//alert('not checked');
		switch(language){
			case "dk":
				errMsg = "Skal udfyldes.";
				break;
			case "no":
				errMsg = "Skal utfylles.";
				break;
			case "eng":
				errMsg = "Required";
				break;
			case "de":
				errMsg = "Pflichtfeld";
				break;
			case "se":
				errMsg = "Saknas";
				break;
			case "nl":
				errMsg = "Verplicht veld";
				break;
			case "fr":
				errMsg = "Champs obligatoire";
				break;

		}
		//alert(errMsg);
		msg (infofield, "error", errMsg);
		setfocus(valfield);
		return false;
	} else {	
		msg (infofield, "warn", "");
		//alert('checked: ' + radio_value);//////////////////////////////////////
		return true;
	}
}
	
	
// --------------------------------------------
//            get_radio_value
// Returns the value of the checked radio button 
// in a group of radio buttons
// --------------------------------------------	
	
function get_radio_value(valfield){
	radio_value = false;
	for (var i=0; i < valfield.length; i++){
		if (valfield[i].checked){
			var radio_value = valfield[i].value;
		}
	}
	//alert('get_radio_value; radio = ' + radio_value);///////////////
	return radio_value;
}

// --------------------------------------------
//            validateUploadFile
// Validate file for upload
// Returns false if mandatory and empty
// Permits file types specified in the file_array 
// --------------------------------------------

	function validateUploadFile (valfield,   // element to be validated
							 infofield,  // id of element to receive info/error msg
							 required,   // true if required
							 language, 	// language of error messages and warnings
							 /*file_size, // max size of the upload file*/
							 file_array) { // array of accepted file extentions of the download
	
		// Check if the file input isnt empty
/*		var stat = commonCheck (valfield, infofield, required, language);
		if (!stat) {
			return false;
		}*/
		//alert('validateUploadFile');
		if (!valfield.value && required == false){
			msg (infofield, "warn", "");
			return true;
		} 
		
		
		// Extract the file extension of the upload file
		var file = valfield.value;
		while (file.indexOf("\\") != -1){
			file = file.slice(file.indexOf("\\") + 1);
		}
		file = file.slice(file.indexOf(".")).toLowerCase();
		
		// Loop array of allowed file extentions and check if the file extention of the upload within the array
		// if its not return false and appropriate error message
		var errMsg = "";
		for (var i = 0; i < file_array.length; i++) {
			//alert('For loop ext; ' + file_array[i]); ///////////////
			if (file_array[i] == file) { 
				//alert('if = true ' + file_array[i]); ///////////////
				var file_ok = true;
				errMsg = "";
				break;
			}
			if (i == 0) {
				errMsg = file_array[i];
			}
			else if (i == file_array.length - 1){
				switch (language) {
					case "se":
						errMsg = errMsg + " och " + file_array[i];
						break;
				}
			}
			else {
				errMsg = errMsg + ", " + file_array[i];
			}	
		}
		
		if (!file_ok) {
			if (errMsg){
				switch(language){
					case "dk":
						errMsg = "Kun file af type " + errMsg;
						break;
					case "fi":
						errMsg = "Vain tiedostotyyppi " + errMsg;
						break;
					case "se":
						errMsg = "Endast filer av typ " + errMsg;
						break;		
				}
			}
			msg(infofield, "error", errMsg);
			setfocus(valfield);
			//alert('errMsg ' + errMsg); ///////////////
			return false;
		} else {
/*			// Check if the file is within the specified filesize
			// browser cant read file info from client computer --> use ajax in order to do this
			alert('file_ok ' + file_ok + "\nSjekk filstørrelse"); ///////////////			
			if(!validateFileSize(valfield) ){
				errMsg = "Filen er for stor";
				msg(infofield, "error", errMsg);
				setfocus(valfield);
				//alert('errMsg ' + errMsg); ///////////////
				return false;
			} else {
				alert('FIl ok'); ///////////////
				return true;
			}*/
			msg (infofield, "warn", "");
			return true;
		}
	}
