/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsOnError
*** Browser   : Microsoft 3.x oder Netscape 3.x
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : err_msg = Auszugebende Nachricht.
*** Returnwert: False
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion oeffnet eine Dialogbox mit der als 
***               Parameter uebergebeneden Nachricht.
*** Created by  : 05.03.1999 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsOnError(err_msg)
{
	alert(err_msg);
   return false;	
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsGetParamValue
*** Browser   : Microsoft 3.x oder Netscape 3.x
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : pUrl   = Location, z.B. "self.window.location.search"
***             pParam = Name des Parameters
*** Returnwert: Value von pParam bei Erfolg, andernfalls Null.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion prueft ob in dem angegebenen URL-String
*** 					der uebergebenen Parameter vorkommt, und liefert 
***               dessen Wert zurueck. Existiert der Parameter pParam 
*** 					nicht, wird ein Null-String zurueckgeliefert.
*** Created by  : 17.04.2000 Lukas Fof
*** Updated by  : 24.06.2000 Clemens Kolbenschlag
***********************************************************************/
function jsGetParamValue(pUrl,pParam)
{
	var sValue = "";
	var nLength = pParam.length;
	var nIndex = pUrl.indexOf(pParam+"=");
	if( nIndex != -1 )
	{
		if( (pUrl.indexOf("&")) == -1 )
		{
			sValue=pUrl.substr(nIndex+nLength+1,pUrl.length);
			return sValue;
		}	
		else
		{
			var sTmp = "";
			var sToken = pUrl.split("&");
			for( i = 0; i < sToken.length; i++ )
			{
				sTmp = sToken[i];
				nIndex=sTmp.indexOf(pParam+"=");
				if( nIndex != -1 )
				{
					sValue=sTmp.substr(nIndex+nLength+1,sTmp.length);
					return sValue;
				}
			}
		}
	}
	return sValue;
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsNullFilter
*** Browser   : Microsoft 3.x oder Netscape 3.x
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : filterstring = String der gefiltert werden soll.
*** Returnwert: Leerer String wenn Funktion zum Einsatz kommt, 
***             andernfalls unveraenderter Parameterwert.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion prueft ob der uebergebene String einen 
*** 					undefinierten oder null-Wert enhaelt und liefert dann
***               einen leeren String zurueck. Andernfalls bleibt der 
*** 					Inhalt des Strings unberuehrt.
*** Created by  : 20.02.2000 Clemens Kolbenschlag
*** Updated by  :
***********************************************************************/
function jsNullFilter( filterstring )
{
	if( filterstring == null || filterstring == "undefined" || filterstring == 0 )
		filterstring = "";
   return filterstring;	
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsChangeFormat
*** Browser   : Microsoft 3.x oder Netscape 3.x
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : pNumber = Wert
*** Returnwert: Der konvertierte Wert bei Erfolg, andernfalls NaN.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion ersetzt das Dezimalkomma in den Dezimal-
*** 					punkt und entfernt fuehrende Blanks. Die Zahl bleibt 
***               unveraendert, wenn das Dezimalzeichen bereits ein 
*** 					Punkt ist oder es sich bei dem Parameter um eine 
***               Ganzzahl handelt. Ist der Parameter allerdings keine 
***               Zahl, so liefert die Funktion "NaN" (Not a Number) 
***               zurueck.
*** Created by  : 14.05.1999 Clemens Kolbenschlag
*** Updated by  : 26.06.2000 Clemens Kolbenschlag
*** --------------------------------------------------------------------
*** ACHTUNG: jsFilterRegEx ersetzt diese Funktion größtenteils.
***********************************************************************/
function jsChangeFormat( pNumber )
{
	var n = "";
	var nRet = 0;
	
	if( pNumber.length <= 0 )
		return nRet;
		
	for( i = 0; i < pNumber.length; i++ )
	{
		if( pNumber.charAt(i) == "," )
			n = n + ".";
		else if( pNumber.charAt(i) == " " )
			n = n;
		else
			n = n + pNumber.charAt(i);
	}

	if( !jsIsFloat(n) )
		return ("NaN");

	nRet = parseFloat( n );
	return nRet;
}

// -----------------------------------------------------------------------
// Copyright   : Media Solutions GmbH
//	Function 	: fmtNum2Str(fNum,cOption)
//	Parameter	: pNumber : float
//					  cOption : String	
//					  		$ 						: US - Format (.)
//							kein $				: DE - Format (,)
//							^ 						: Tausenderpunkte
//							.Nachkommastellen : z.B.:  .2		(Auf/Abrunden)				
//	Return		: fResult : formatierter float 
//	Author		: Lfof
//	Date			: 13.06.00
// -----------------------------------------------------------------------	
function fmtNum2Str(pNumber,cOption)
{
	var sNumber = "";			// Number als String
	var fResult = "";			// Ergebnis-String

	// -----------------------------------------------------------------------		
	// Optionen auswerten...
	// -----------------------------------------------------------------------
	var sCountry = ""; 				// Laenderkennzeichen
	var sDSign = ""; 					// Dezimal-Zeichen
	var sTSign = ""; 					// Tausender-Zeichen
	var nDDigit = -1; 				// Dezimal-Stellen
	var cDigits = "0123456789";	// Erlaubte Zahlen
	
	for( i=0; i < cOption.length; i++ )
	{
		if( cOption.charAt(i) == "$" ) 
			sCountry = "$";
		else if( cOption.charAt(i) == "^" ) 
			sTSign = "^";
		else if( cOption.charAt(i) == "." ) 
		{
			sDSign = ".";
			if( i < (cOption.length-1) )
				if( cDigits.indexOf(cOption.charAt(i+1)) >= 0 )
					nDDigit = parseInt(cOption.charAt(i+1));
		}
	}

	if( sCountry == "$" )
	{
		if( sDSign == "." )
			sDSign = ".";
		if( sTSign == "^" )
			sTSign = ",";
	}	
	else
	{
		if( sDSign == "." )
			sDSign = ",";
		if( sTSign == "^" )
			sTSign = ".";
	}	

	// -----------------------------------------------------------------------
	// Parameter konvertieren...
	// -----------------------------------------------------------------------
	if( pNumber == "" )
		pNumber = 0;
	sNumber = "" + pNumber;

	// -----------------------------------------------------------------------
	// Parameter pruefen...
	// -----------------------------------------------------------------------
	if( !jsIsFloat(sNumber) )
		return ("NaN");
	
	// -----------------------------------------------------------------------
	// Vorzeichen ermitteln...
	// -----------------------------------------------------------------------
	var sPlusMinus = ""; 	// Vorzeichen

	if( sNumber.charAt(0) == "-" || sNumber.charAt(0) == "+" )
	{
		sPlusMinus = sNumber.charAt(0);
		sNumber = sNumber.substring( 1, sNumber.length );
	}

	// -----------------------------------------------------------------------	
	// Dezimalstellen setzen...
	// -----------------------------------------------------------------------
	if( nDDigit > 0 )
	{
		// Auf 'nDDigit' Dezimalstellen runden.
		for( i=1, j=1; i <= nDDigit; i++ )
				j = j * 10;
		sNumber = "" + Math.round(j * sNumber);
		if( nDDigit == sNumber.length )
			fResult = "0"+sDSign+""+ sNumber.substring(sNumber.length-nDDigit);
		else
			fResult = sNumber.substring(0,sNumber.length-nDDigit) +""+sDSign+""+ sNumber.substring(sNumber.length-nDDigit);
	}
	else if( nDDigit == 0 )
	{
		// Auf Null Dezimalstellen runden.
		sNumber = "" + Math.round(1 * sNumber);
		fResult = sNumber;
	}
	else
	{
		// Anzahl der Dezimalstellen unbekannt.
		if( sNumber.indexOf(".") < 0 )
		{
			nDDigit = 0;
			fResult = sNumber;
		}
		else
		{
			nDDigit = sNumber.length - sNumber.indexOf(".") - 1;
			// Check ob die Option 'Dezimalpunkt' nicht doch automatisch gesetzt werden sollte, 
			// falls die Option bisher noch nicht gesetzt war.
			if( sDSign == "" && nDDigit > 0 && sCountry == "$" )
				sDSign = ".";
			else if( sDSign == "" && nDDigit > 0 && sCountry == "" )
				sDSign = ",";
			fResult = sNumber.substring(0,sNumber.length-nDDigit-1) +""+sDSign+""+ sNumber.substring(sNumber.length-nDDigit);
		}
	}

	// -----------------------------------------------------------------------	
	// Tausenderpunkte setzen...	
	// -----------------------------------------------------------------------	
	if( sTSign != "")
	{
		var nNachkommastellen = 0;
		if( nDDigit > 0 )
			nNachkommastellen = (1 + nDDigit);

		var nRest = (fResult.length-nNachkommastellen)%3;				
		var nTPunkte = (fResult.length-nNachkommastellen-nRest)/3;
		
		if( nRest == 0 )
			nTPunkte--; 

		var TSigns = 0;	// Anzahl der bereits gesetzten Tausender-Zeichen.
		for( i=1; i <= nTPunkte; i++ )
		{
			if( nDDigit > 0 )
				fResult = fResult.substring(0,fResult.indexOf(sDSign)-(i*3+TSigns)) + ""+sTSign+"" + fResult.substring(fResult.indexOf(sDSign)-(i*3+TSigns));
			else
				fResult = fResult.substring(0,fResult.length-(i*3+TSigns)) + ""+sTSign+"" + fResult.substring(fResult.length-(i*3+TSigns));
			TSigns++;
		}
	}

	// -----------------------------------------------------------------------	
	// Vorzeichen wieder einsetzen nicht vergessen.
	// -----------------------------------------------------------------------	
	if( sPlusMinus == "-" && fResult != 0 )
		fResult = "" + sPlusMinus + fResult;

	// -----------------------------------------------------------------------	
	// Debugging...
	// -----------------------------------------------------------------------	
/*
	sDebug = "Parameter: "+pNumber+"\n";
	sDebug += "Options:\t\t"+cOption+"\n";
	sDebug += "------------------------------------\n";
	sDebug += "Countryformat: \t["+sCountry+"]\n";
	sDebug += "Vorzeichen: \t["+sPlusMinus+"]\n";
	sDebug += "Tausenderpunkt: \t["+sTSign+"]\n";
	sDebug += "Dezimalpunkt: \t["+sDSign+"]\n";
	sDebug += "Dezimalstellen: \t["+nDDigit+"]\n";
	sDebug += "------------------------------------\n";
	sDebug += "Ergebnis: "+fResult+"\n";
	alert( sDebug );
	return;
*/
	return fResult;
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsExistValue
*** Browser   : Microsoft 3.x oder Netscape 3.x
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : obj      = Pointer auf das Objekt
***             obj_type = Type des Objektes
*** Returnwert: False, falls kein Wert eingetragen bzw. selektiert wurde.
***             Bei den Typen SELECT, RADIO und CHECKBOX wird der Index 
***             des selektierten Wertes zurueckgeliefert.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion prueft ob bei dem Objekt ein Wert einge-
***               tragen bzw. selektiert wurde.
*** Created by  : 14.05.2000 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsExistValue( obj, obj_type )
{
	if ( obj_type == "TEXT" || obj_type == "PASSWORD" )
	{
		if( obj.value.length == 0 ) 
      	return false;
    	else 
      	return true;
   }
   else if (obj_type == "SELECT")
	{
   	for (i=0; i < obj.length; i++)
	   {
			if (obj.options[i].selected)
				return i;
		}
   	return false;	
	}
   else if (obj_type == "SINGLE_VALUE_RADIO" || obj_type == "SINGLE_VALUE_CHECKBOX")
	{
		if (obj.checked)
			return true;
		else
     		return false;	
	}
   else if (obj_type == "RADIO" || obj_type == "CHECKBOX")
	{
      for (i=0; i < obj.length; i++)
    	{
			if (obj[i].checked)
				return i;
		}
     	return false;	
	}
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsIsChecked
*** Browser   : Microsoft 3.x oder Netscape 3.x
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : obj      = Pointer auf das Objekt (Radiobutton)
*** Returnwert: -1, falls kein Wert eingetragen bzw. selektiert wurde,
***				sonst der Index des Radiobuttons
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion prueft ob ein Radiobutton selektiert wurde.
*** Created by  : 11.08.2003 Clemens Kolbenschlag, Andreas Berleth
*** Updated by  : 
***********************************************************************/
function jsIsChecked( obj )
{
	if ( obj.length == undefined ) // falls nur ein Radiobutton
	{
		if ( obj.checked )
		{
			return 0;
		}
		else
		{
			return (-1);
		}
	}
	else
	{
		nIdx = (-1);
		for( i=0; i < obj.length; i++ )
		   if( obj [i].checked == true )
		     nIdx = i;
		     
		return nIdx;
	}
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsIsFloat
*** Browser   : Microsoft 3.x oder Netscape 3.x
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : pValue = Wert, der ueberprueft werden soll.
*** Returnwert: True, falls der Wert eine Gleitkommazahl ist.
***             False, falls keine Zahlen, fuehrende Blanks oder 
***             trennende Blanks enthalten sind.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion prueft ob es sich bei dem Wert 'nValue' 
***               um eine positive oder negative Gleitkommazahl handelt. 
*** Created by  : 25.06.2000 Clemens Kolbenschlag
*** Updated by  : 09.04.2002 CLK+ANB+PEW (jaja die regexp)
***********************************************************************/
function jsIsFloat(pValue)
{
	pValue = "" + pValue;
	var sIsFloat = /^[+-]?[0-9]*[,.]?[0-9]+$/;
	return sIsFloat.test(pValue);
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsIsInteger
*** Browser   : Microsoft 4.x oder Netscape 3.x
*** Version   : JavaScript 1.1 
*** --------------------------------------------------------------------
*** Parameter : pValue = Wert, der ueberprueft werden soll.
*** Returnwert: True, falls der Wert eine Ganzzahl ist.
***             False, falls keine Zahlen, fuehrende Blanks oder 
***             trennende Blanks enthalten sind.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion prueft ob es sich bei dem Wert 'nValue' 
***               um eine positive oder negative Ganzzahl handelt. 
*** Created by  : 25.06.2000 Clemens Kolbenschlag
*** Updated by  : 11.04.2002 CLK+ANB+PEW (jaja die regexp)
***********************************************************************/
function jsIsInteger(pValue)
{
	var sIsInteger = /^[+-]?[0-9]+$/;
	return sIsInteger.test(pValue);
}

/************************************************************************
	Function 	: jsVerifyInteger( pValue, sOperator )
					: sOperator - GT, GE, LE, LT
	Author		: PEW / CLK
	Date			: 05.04.2002
*************************************************************************/
function jsVerifyInteger( pValue, sOperator )
{
	var sVorzeichen = /[+-]/;
	if( sVorzeichen.test(pValue) && pValue.length <= 1 )
		return false;
	
	switch( sOperator )
	{
		case 'GT': 	
		case 'GE': 	sVerifyInteger = /^[+0-9]([0-9])*$/;
						break;
		case 'LE': 	
		case 'LT': 	sVerifyInteger = /^[-0-9]([0-9])*$/;
						break;
		default:		return false;
						break;
	}
	nReturn = sVerifyInteger.test(pValue);
	if( !nReturn )
		return false;
	
	if( parseFloat(pValue) == 0 && sOperator.charAt(1) == "T" )
		return false;
		
	return true;
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsCheckRange
*** Browser   : Microsoft 3.x oder Netscape 3.x
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : obj_value = Wert, der ueberprueft werden soll.
***             min_value = Erlaubter Minimalwert.
***             max_value = Erlaubter Maximalwert.
*** Returnwert: True, wenn der Wert innerhalb der Grenzwerte liegt.
***             False, falls der Wert kleiner oder groesser der 
***             angegebenen Grenzwerte liegt.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion prueft ob der uebergebene Wert kleiner 
***               als der Minimalwert oder groesser als der Maximalwert 
***               ist.
*** Created by  : 14.05.1999 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsCheckRange(obj_value, min_value, max_value)
{
   if( obj_value.length == 0 )
		return true;

   // Minimalwert
	if( min_value != null )
	{
  		if ( (obj_value) < (min_value) )
			return false;
	}
	// Maximalwert
  	if( max_value != null )
	{
		if( (obj_value) > (max_value) )
			return false;
	}

   // Alle Tests erledigt, also...
   return true;
}


/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsExtractFileName
*** Browser   : Microsoft 3.x oder Netscape 3.x
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : sSting = Pfad- und Dateiname.
***             sPart  = Zu extrahierender Teil {FILENAME|EXTENSION}.
***             max_value = Erlaubter Maximalwert.
*** Returnwert: Bei Part FILENAME wird der Dateiname inkl. der Extension 
***             zurueckgeliefert.
***             Bei Part EXTENSION wird nur die Extension der Datei 
***             zurueckgeliefert.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion ermittelt aus der relativen oder der 
***               absoluten Pfadangabe 'sString' ja nach Anforderung 
***               'sPart' den vollstaendigen Dateinamen oder nur die 
***               Extension des Dateinamens. 
*** Created by  : 25.06.1999 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsExtractFileName(sString,sPart)
{
	var sExt = "";
	var sFile = "";
	var sReturn = "";
	var nTokenAnz = 0;
	var sToken = new Array();
	
	if( sString == null || sPart == null )
		return sReturn;
	
	if( sString.indexOf("\\") >= 0 )
		sToken = sString.split( "\\" ); 	// DOS-Dateisystem
	else
		sToken = sString.split( "/" );		// UNIX-Dateisystem
	
	nTokenAnz = sToken.length;	

	// Dateiname + Extension ermitteln...
	sFile = sToken[nTokenAnz-1];

	// Extension ermitteln...
	sToken = sFile.split( "." );
	nTokenAnz = sToken.length;
	if( nTokenAnz >= 2 )
		sExt = sToken[nTokenAnz-1];

	// Anforderung zurueckgeben...
	if( sPart == "FILENAME" ) 
		sReturn = sFile;
	else if( sPart == "EXTENSION" )
		sReturn = sExt;
		
	return sReturn;
}

/************************************************************************
	Function 	: jsCheckMail( pMail )
	Author		: PEW / ANB
	Date			: 02.04.2002
	Wird ein zweiter Parameter übergeben, so wird geprüft, ob jedes Element
	der Liste (getrennt durch Semikolon) eine gültige Mail-Adresse enthält.
*************************************************************************/
function jsCheckMail( pMail, pAdvanced )
{
	// Neuere Versionen verwenden einen 2.Parameter...
	if( jsCheckMail.arguments.length > 1 )
		pAdvanced = true;
	else
		pAdvanced = false;

	var sMailtrenner = /[;]/;
	var sMail = /^[-_A-Za-z0-9]+(\.?[-_A-Za-z0-9])*@([-A-Za-z0-9]+\.)+([A-Za-z]{2,4})$/;

	if( sMailtrenner.test(pMail) && pAdvanced )
	{
		var sToken = pMail.split(";");
		for( i = 0; i < sToken.length; i++ )
		{
			sTmp = sToken[i];
			if( !sMail.test(sTmp) )
				return false;
		}
		return true;
	}
	else
	{
		return sMail.test(pMail);
	}
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsFilterRegEx
*** Browser   : Microsoft 4.x oder Netscape 4.x
*** Version   : JavaScript 1.2 
*** --------------------------------------------------------------------
*** Parameter : sValue = Wert, der ueberprueft werden soll.
***             sRegEx = Regular-Expresion mit den Zeichen die ersetzt 
***                      werden sollen (z.B. [.] für alle Punkte oder 
***                      \s für die White Spaces.).
***             sStr   = Zeichen die stattdessen eingetragen werden 
***                      sollen.
*** Returnwert: Der gefilterte Wert.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion sucht über die angegene RegEx (sRegEx) 
***               alle vorkommen im uebergebene Wert sValue und ersetzt 
***               diese durch sStr und gibt den neuen Wert an die 
***               aufrufende Funktion zurück.
*** Created by  : 18.06.2002 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsFilterRegEx( sValue, sRegEx, sStr )
{
	while( eval("sValue.search(/"+sRegEx+"/)") >= 0 )
	 	sValue = eval("sValue.replace(/"+sRegEx+"/,\""+sStr+"\")");
	return sValue;
}

/************************************************************************
	Function 	: jsCheckPwd( pValue, nChars )
	Author		: ANB
	Date			: 26.03.2003
	Funktion		: prüft, ob die übergebene Zeichenkette mindestens so lang
					  ist, wie in nChars angegeben. Ist dies der Fall, wird 
					  geprüft, ob die Zeichenkette mindestens eine Zahl oder ein
					  Sonderzeichen enthält.
*************************************************************************/
function jsCheckPwd( pValue, nChars )
{
	var sSpChar = /[\W0-9]/
	var sAlpha = /[a-zA-Z]/
	if ( sSpChar.test( pValue ) && sAlpha.test(pValue) && pValue.length >= nChars )
//	if ( sAlpha.test(pValue) )
	{
		return true;
	}
	else
	{
		return false;
	}
}