// <!-- hide it 

//======================================================================
// File:	     common.js (c) 
// Copyright:        Bangalore AB 2002, all rights reserved.
// Public methods:   validateDate    Validates dates
//                   validateNumber   Validates numbers

//----------------------------------------------------------------------
// Public methods:
//----------------------------------------------------------------------

//---------------------------------
// Name:       validateDate
// Purpose:    Validates dates
// Parameter1: element, the element object to validate. Use "this" as parameter to ensure the right element is invoked and in focus after an error input
// Parameter2: mask, the format msk for the dateformat, ie  'yyyymmdd' , 'yymmdd hh24:mi' , 'hh24:mi yyyymmdd' etc
// Parameter3: errorMsg, the error message to send in an alert window if the elements value was not a valid date in the given dateformat.
// Example:    .... ONCHANGE="validateDatum(this,'yyyymmdd','Ang din födelseår i formatet yyyymmdd')"
//
function validateDate (element, mask, errorMsg) {
    	

		
		if (element.value.length != mask.length){
			alert(errorMsg);
			goToElement(element);
			return (false);
		}
		thisManad = 0;
      	thisDag = 0;
      	thisAr = 0;
      	k = 0;
      	st = new stromKlass(element.value);
      	maskSt  = new stromKlass(mask);
      	
      	while( !(st.peekNext() == "") ) {
		if ( !( parseGrupp(st, maskSt) && parseDelimiter(st, maskSt) )) {
			alert (errorMsg);
			
        	goToElement(element)
			 return (false);
		}
		
	}
        if ( ((thisManad != 0) && (thisDag <= dagarPerManad[thisManad])) || (thisDag == 0) ){ 
        	return(true) 
        } 
        else {
        	alert (errorMsg);
			
        	goToElement(element)
		 return (false);
	}
}


//---------------------------------
// Name:       validateNumber
// Purpose:    Validates numbers
// Parameter1: element, the element object to validate. Use "this" as parameter to ensure the right element is invoked and in focus after an error input
// Parameter2: errorMsg, the error message to send in an alert window if the elements value wasn't a number.
// Example:    .... ONCHANGE="validateNumber(this,'Incorrect salary, please use only numbers')"
//
function validateNumber (element, errorMsg) {
  tal = new stromKlass(element.value);
  
  
  if( tal.peekNext() == "-") {
      tal.getNext();
  }

  foundDelimeter = false;

  while ( !(tal.peekNext() == "") ) {
    if( arSiffra(tal.peekNext()) ) {
       tal.getNext();
    }
    else {
        if( (tal.peekNext() == "." || tal.peekNext() == ",") && foundDelimeter == false ) {
            foundDelimeter = true;
            tal.getNext();
         }
         else {
            alert (errorMsg);
			
        	goToElement(element)
            return (false);
         }
     }
  }
  
  return (true);
}


//---------------------------------
// Name:       validateInterval
// Purpose:    Validates numbers for an specific interval 
// Parameter1: min, the min value for the interval
// Parameter2: max. the max value for the interval 
// Parameter3: element, the element object to validate. Use "this" as parameter to ensure the right element is invoked and in focus after an error input
// Parameter4: errorMsg, the error message to send in an alert window if the elements value wasn't a number.or not in interval
// Example:    .... ONCHANGE="validateInterval(0,10,this,'Please use an number inte interval 0 to 10')"
//
function validateInterval( min, max, element, errorMsg) {
  validateNumber (element, errorMsg);
  if((element.value < min || element.value > max) && element.value.length > 0) {
  	alert (errorMsg);
			
        	goToElement(element)
        return (false);
  }
  return (true);
}


//---------------------------------
// Name:       validateMaxLength
// Purpose:    Validates max length for an elements value   
// Parameter1: max. the max text length
// Parameter2: element, the element object to validate. Use "this" as parameter to ensure the right element is invoked and in focus after an error input
// Parameter3: errorMsg, the error message to send in an alert window if the elements value exceeded max length
// Example:    .... ONCHANGE="validateMaxLength(10, this, 'Text length exceeded!')"
//
function validateMaxLength( max, element, errorMsg) {
  if(element.value.length > max) {
     alert (errorMsg);
			
        	goToElement(element)
     return (false);
  }
  return (true);
}


//---------------------------------
// Name:       validateNotEmpty
// Purpose:    Validates that an elements value isn't empty   
// Parameter1: element, the element object to validate.  Use "this" as parameter to ensure the right element is invoked and in focus after an error input
// Parameter2: errorMsg, the error message to send in an alert window if the elements value is null
// Example:    .... ONCHANGE="validateNotEmpty(this, 'You must enter a value!')"
//
function validateNotEmpty(element, errorMsg) {
  if(element.value.length <= 0) {
     alert (errorMsg);
     goToElement(element)
     return (false);
  }
  return (true);
}

//MoL
function validateEmpty(element, errorMsg) {
   if(element.value.length > 0) {
      alert (errorMsg);
      goToElement(element);
      return (false);
   }
   return (true);
}


//---------------------------------
// Name:       emailCheck
// Purpose:    Validates that an elements value is a valid email.   
// Parameter1: element, the element object to validate. Use "this" as parameter to ensure the right element is invoked and in focus after an error input
// Example:    .... ONCHANGE="validateEmail(this)"
//
function emailCheck (emailStr) {
    var emailPat=/^(.+)@(.+)$/;
    var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]åäöÅÄÖ";
    var validChars="\[^\\s" + specialChars + "\]";
    var firstChars=validChars;
    var quotedUser="(\"[^\"]*\")";
    var atom="(" + firstChars + validChars + "*" + ")";
    var word="(" + atom + "|" + quotedUser + ")";
    var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
    var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");

    /* Finally, let's start trying to figure out if the supplied address is
       valid. */

    var matchArray=emailStr.match(emailPat);
    if (matchArray==null) {
      /* Too many/few @'s or something; basically, this address doesn't
         even fit the general mould of a valid e-mail address. */
        alert("Email adressen är felaktig (kontrollera @ och punkternas placering mm)");
        return false;
    }
    var user=matchArray[1];
    var domain=matchArray[2];// See if "user" is valid
    if (user.match(userPat)==null) {
        // user is not valid
        alert("Mailadressen är felaktig före @");
        return false;
    }

    // Domain is symbolic name
    var domainArray=domain.match(domainPat);
    if (domainArray==null) {
        alert("Mailadressen är felaktig efter @");
        return false;
    }

    /* Now we need to break up the domain to get a count of how many atoms
       it consists of. */
    var atomPat=new RegExp(atom,"g");
    var domArr=domain.match(atomPat);
    var len=domArr.length;
    if (domArr[domArr.length-1].length<2 ||
        domArr[domArr.length-1].length>4) {
       // the address must end in a two letter or three letter word.
       alert("Sista delen av mailadressen måste bestå av två till fyra bokstäver");
       return false;
    }

    if (emailStr.lastIndexOf(".")==emailStr.length-1) {
       // the address must not end with a .
       alert("Mailadressen får inte sluta med en punkt.");
       return false;
    }
    if (emailStr.lastIndexOf(".")<emailStr.lastIndexOf("@")) {
       // the address must have a . after @
       alert("Domän namnet (efter @) måste innehålla minst en punkt.");
       return false;
    }

    // If we've gotten this far, everything's valid!
    return true;
}


//----------------------------------------------------------------------
// Private help functions
//----------------------------------------------------------------------
// Kludge för en bug i Navigator 2.0.2

function goToElement(element) {
	// element.focus();
	if ( element.type.indexOf('select') != -1)
	{
		element.focus();
	}else{
		element.select();
	}
}

function charInString (c, s) {
    for (i = 0; i < s.length; i++)
    {   if (s.charAt(i) == c) return true;
    }
    return false
}

function strippaTecken (s,s2) {
    var i = 0;
    while ((i < s.length) && charInString (s.charAt(i), s2))i++;
    return s.substring (i, s.length);
}

function stromKlass (s){
    this.string = s;
    this.index = 0;
    this.getNext = getNextMethod;
    this.peekNext = peekNextMethod;
    this.peekSecondNext = peekSecondNextMethod;
}

function getNextMethod() {
    if (this.index >= this.string.length) {return("")}
    else
    {this.index += 1;
     return(this.string.charAt(this.index-1));
     }
}

function peekNextMethod() {
    if (this.index >= this.string.length) {return("")}
    else
    { return(this.string.charAt(this.index)); }
}


function peekSecondNextMethod() {
   if (this.index >= this.string.length) {return("")}
    else
    { return(this.string.charAt( this.index + 1 )); }
}


// Dum bug som parsar alla strängar som börjar med "0" till 0

function myParseInt (s) {
  if (arHeltal(s)) {return(parseInt(strippaTecken(s,"0")))}
  else {return(false)}
  }


//----------------------------------------------------------------------
// Funktioner för felmeddelanden
//----------------------------------------------------------------------

function prompt (s) { window.status = s }


//----------------------------------------------------------------------
// Domändeklarationer och typtester
//----------------------------------------------------------------------

var siffror = "0123456789"

function arSiffra(s) { return(siffror.indexOf(s) != -1) }

function arHeltal (s){
    for (var i = 0; i < s.length; i++){
      if (!arSiffra(s.charAt(i))) return false;
    }
    return true;
}

//----------------------------------------------------------------------
// Valideringsmetoder - en per typ.
//----------------------------------------------------------------------
// Enkel validering av datumsträng enligt: ÅÅ/MM/DD

var dagarPerManad = new Array();
dagarPerManad[1] = 31;  dagarPerManad[2] = 29;  dagarPerManad[3] = 31;
dagarPerManad[4] = 30;  dagarPerManad[5] = 31;  dagarPerManad[6] = 30;
dagarPerManad[7] = 31;  dagarPerManad[8] = 31;  dagarPerManad[9] = 30;
dagarPerManad[10] = 31; dagarPerManad[11] = 30; dagarPerManad[12] = 31;
//------------------------------------------
function parseAr (st, stMask) {
    var iMask = 0;
    while (stMask.peekNext() == "y") {stMask.getNext();iMask += 1};
    ar = "";
    for (var i = 0; i < iMask; i++) {ar = ar + st.getNext()}
    return (arHeltal(ar) && ar.length == iMask);
    }
//-------------------------------------------
function parseMan (st, stMask) {
    var iMask = 0;
    while (stMask.peekNext() == "m") {stMask.getNext();iMask += 1};
    man = "";
    for (var i = 0; i < iMask; i++) {man = man + st.getNext()}
    thisManad = myParseInt (man);
    return (thisManad && arHeltal(man) && man.length == 2 && thisManad >  0 && thisManad < 13);
    }
//-------------------------------------------
function parseDag (st, stMask) {
    var iMask = 0;
    while (stMask.peekNext() == "d") {stMask.getNext(); iMask += 1};
    dag = "";
    for (var i = 0; i < iMask; i++) {dag = dag + st.getNext()}
    thisDag = myParseInt (dag);
    return (thisDag && arHeltal(dag) && dag.length == 2 && thisDag >  0 && thisDag <= 31);
 }

//-------------------------------------------
function parseTime (st, stMask) {
    //Get hh
    var iMask = 0;
    while (stMask.peekNext() == "h") {stMask.getNext(); iMask += 1};
    hour = "";
    for (var i = 0; i < iMask; i++) {
    	hour = hour + st.getNext()
    }
    thisHour = parseInt (hour);
        
    //If there are no number after "hh" then it is 12 hour
    if( stMask.peekNext() == ":" ) {
    	alert('Aboo');
    	return (arHeltal(hour) && thisHour >= 1  && thisHour <= 12 );
    }  
    
    //See if it 12 our 24 hours
    hourMask = "";
    hourMask = hourMask + stMask.peekNext();
    hourMask = hourMask + stMask.peekSecondNext(); 
    
    //If the mask is hh:24
    if(hourMask == "24") {
    	stMask.getNext();
    	stMask.getNext();
    	return (arHeltal(hour) && thisHour >= 0  && thisHour < 24 );
    }  
    
    //If he mask is hh:12
    if(hourMask == "12") {
    	stMask.getNext();
    	stMask.getNext();
    	return (arHeltal(hour) && thisHour >= 1 && thisHour <= 12);
    }    
    else {
    	return (false);
    }
}

//-------------------------------------------
function parseMin (st, stMask) {
    var iMask = 0;
    min = "";
    if( (stMask.peekNext() == "m") && (stMask.peekSecondNext() == "i") ) {
    	stMask.getNext();
    	min = min + st.getNext();
    	stMask.getNext();
    	min = min + st.getNext(); 	
    }  
    thisMin = parseInt (min);   
    return (arHeltal(min) && min.length == 2 && thisMin >=  0 && thisMin <= 59);
}


function parseGrupp (st, maskSt) {
    mask1 = maskSt.peekNext(); mask2 = maskSt.peekSecondNext();
    if ((mask1 == "m") && (mask2 == "m") ) {return (parseMan(st, maskSt))};
    if (mask1 == "d") {return (parseDag(st, maskSt))};
    if (mask1 == "y") {return (parseAr(st, maskSt))};
    if (mask1 == "h") {return (parseTime(st, maskSt))};
    if ( (mask1 == "m") && (mask2 == "i") ) {return (parseMin(st, maskSt))};
}


function parseDelimiter(st, maskSt) {
    delT = maskSt.peekNext();
    if (delT == " " || delT == ";" || delT == "," || delT == "/" || delT == "-" || delT == ":") {
       return(st.getNext() == maskSt.getNext());
       }
       else
       {return (true)}
}

function blocking(nr)
{
	if (document.getElementById){
		current = (document.getElementById(nr).style.display == 'block') ? 'none' : 'block';
		document.getElementById(nr).style.display = current;
	}else if (document.all){
		current = (document.all[nr].style.display == 'block') ? 'none' : 'block'
		document.all[nr].style.display = current;
	}else if (document.layers){
		var i = parseInt(nr.substr(nr.length-1,1));
		//var replacing = heights[i-1];
		var replacing = 1;
		if (shown[i]){
			shown[i] = false;
			replacing = -replacing;
			document.layers[nr].visibility = 'hide';
			document.layers[nr].top = safe;
		}else{
			shown[i] = true;
			document.layers[nr].visibility = 'show';
			var tempname = 'header' + i;
			document.layers[nr].top = document.layers[tempname].top + headerheight;
		}
		for (j=(i+1);j<=max;j++){
			name1 = 'header' + j;
			document.layers[name1].top += replacing;
			if (shown[j]){
				name2 = 'number' + j;
				document.layers[name2].top += replacing;
			}
		}
	}
	else alert ('This link does not work in your browser.');
}

function moveSelectedOptions(from,to) {
	// Move them over
	for (var i=0; i<from.options.length; i++) {
		var o = from.options[i];
		if (o.selected) {
			to.options[to.options.length] = new Option( o.text, o.value, false, false);
		}
	}
	// Delete them from original
	for (var i=(from.options.length-1); i>=0; i--) {
		var o = from.options[i];
		if (o.selected) {
			from.options[i] = null;
		}
	}
	from.selectedIndex = -1;
	to.selectedIndex = -1;
	from=null;
	to=null;
}

function copySelectedOptions(from,to){
	var add = true;
	for (var i=0; i<from.options.length; i++) {
		var o = from.options[i];
		add = true;
		if (o.selected) {
			for (var l=0;l<to.options.length;l++){
				if (to.options[l].text == o.text && to.options[l].value == o.value){
					add = false;
				}
			}
			if (add){
				to.options[to.options.length] = new Option( o.text, o.value, false, false);
			}
		}
	}
	from.selectedIndex = -1;
	to.selectedIndex = -1;
}

function deleteSelectedOptions(from){
	for (var i=(from.options.length-1); i>=0; i--) {
		var o = from.options[i];
		if (o.selected) {
			from.options[i] = null;
		}
	}
	from.selectedIndex = -1;
}

// end hide it -->