/*
function click(e){if (document.all) if (event.button == 2) return false;if
(document.layers) if (e.which == 3) return false;}
function click2(){event.returnValue=false;return false;}if (document.layers)
document.captureEvents(Event.MOUSEDOWN);document.onmousedown=click;document.oncontextmenu=click2;
*/


nn4 = (document.layers)? true:false
ie4 = (document.all)? true:false
function CheckEnterPressed(Ereignis) {
 if (nn4) var taste=Ereignis.which
 if (ie4) var taste=event.keyCode
 if (taste==13) {return true;}
 return false;
}



	function StartOpenNewWindow(paurl,pawidth,paheight,pascrollbars,patoolbar,WindowName)
	{
		WindowName	= 	window.open( paurl,WindowName,'width='+pawidth+',height='+paheight+',dependent=yes,scrollbars='+pascrollbars+',toolbar='+patoolbar+',resizable=yes');
		WindowName.focus();
	}



	function CheckWebConform(paStr)
	{
		var arRestrictedValues = new Array(' ','Ä','ä','Ö','ö','Ü','ü','ß','!','§','$','%','&','{','[',']','}','?');
		var	paReturnValue	= true;
		var  ErrorMessage	= 'FEHLER!\n' +
			  '________________________________________________\n\n' +
			  '['+paStr+']\nist keine gültige Bezeichnung!\n\n' +
			  'Folgende Zeichen sind nicht zulässig:\n\n' +
			  '> Leerzeichen\n' +
			  '> Sonderzeichen\n\n' +
			  '________________________________________________';
		
		
			//alert(ErrorMessage);
		for( i=0; i < arRestrictedValues.length && paReturnValue ; i++)
		{
			if( paStr.indexOf(arRestrictedValues[i]) >= 0 )
			{
				paReturnValue	= false;
			}
		}
		
		
		
		//if( paStr.indexOf(" ") >= 0 )
		//alert( paStr.indexOf(" ") >0 0 );
		if( !paReturnValue )
		{
			alert(ErrorMessage);
		}
		return paReturnValue;
		
	}


	function CheckURLConform(paStr)
	{
		var arRestrictedValues = new Array(' ','Ä','ä','Ö','ö','Ü','ü','ß','!','§','$','%','&','{','[',']','}','?');
		var	paReturnValue	= true;
		var  ErrorMessage	= 'FEHLER!\n' +
			  '________________________________________________\n\n' +
			  '['+paStr+']\nist keine gültige Bezeichnung!\n\n' +
			  'Folgende Zeichen sind nicht zulässig:\n\n' +
			  '> Leerzeichen\n' +
			  '> Sonderzeichen\n\n' +
			  '________________________________________________';
		
		
			//alert(ErrorMessage);
		for( i=0; i < arRestrictedValues.length && paReturnValue ; i++)
		{
			if( paStr.indexOf(arRestrictedValues[i]) >= 0 )
			{
				paReturnValue	= false;
			}
		}
		
		
		
		//if( paStr.indexOf(" ") >= 0 )
		//alert( paStr.indexOf(" ") >0 0 );
		if( !paReturnValue )
		{
			alert(ErrorMessage);
		}
		return paReturnValue;
		
	}

	function DoOpenParamWin(strLocation,NewWinX,NewWinY,NewWinScrollbar,NewWinToolbar,NewResizable,ssl)
	{
		GetLocationHost(strLocation,ssl);
		var OpenedWin;
		OpenedWin = window.open(strLocation,'OpenedWin','width='+NewWinX+',height='+NewWinY+',dependent=yes,scrollbars='+NewWinScrollbar+',toolbar='+NewWinToolbar+',resizable='+NewResizable+'');
		OpenedWin.focus();
	}


	function DoOpenTop(strLocation,ssl)
	{
		GetLocationHost(strLocation,ssl);
		top.location.href = strLocation;
	}


	function DoOpenFullWin(strLocation,ssl)
	{
		GetLocationHost(strLocation,ssl);
		window.open(strLocation);
	}

	function DoOpenSelf(strLocation,ssl)
	{
		GetLocationHost(strLocation,ssl);
		location.href = strLocation;
	}
	
	function DoOpenLocation(strLocation,strTarget,ssl,NewWin,NewWinX,NewWinY,NewWinScrollbar,NewWinToolbar,NewResizable)
	{
		if( NewWin == 1 )
		{
			DoOpenParamWin(strLocation,NewWinX,NewWinY,NewWinScrollbar,NewWinToolbar,NewResizable,ssl);
			return;
		}
		else if( strTarget == '_top')
		{
			DoOpenTop(strLocation,ssl);
			return;
		}
		else if( strTarget == '_blank' || strTarget == '' )
		{
			DoOpenFullWin(strLocation,ssl);
			return;
		}
		else if( strTarget == 'fh_inhalt' )
		{
			DoOpenFHInhalt(strLocation,ssl);
			return;
		}
		else if( strTarget == '_self' )
		{
			DoOpenSelf(strLocation,ssl);
			return;
		}
	}

	function ChangeImage(paName,paPath,paImage)
	{
		eval( "document." + paName + ".src = '" + paPath + paImage + "';" ); 
	}


// ---------------------------------------------------------------
//
//	DoCheckemail
//	@Die Funktion DoCheckemail prueft einen String auf eine 
//	gueltige Email Adresse   
//
// ---------------------------------------------------------------

function DoCheckemail( str )
{
	// Feld darf nicht leer sein
	if( trim(str) == '' )
	{
		alert('Eingabefeld E-Mail darf nicht leer sein!');
		return(false);
	}
	// Auf Zeichen @
	if( str.indexOf("@") == -1 )
	{
		alert('Eingabefeld E-Mail hat falsches Format!\nZeichen -@- fehlt.');
		return(false);
	}
	// Auf Zeichen -.-
	if( str.indexOf(".") == -1 )
	{
		alert('Eingabefeld E-Mail hat falsches Format!\nZeichen -.- fehlt.');
		return(false);
	}
	return(true);
}



// ---------------------------------------------------------------
//
//	CheckMultiselect
// Dieses Skript prueft, ob mindestens ein Feld 
// selektiert worden ist und erstellt fuer jedes ein
// Formfield mit der Bezeichnung:
// n=0; fieldname[n]; n++
// Wenn keines Selektiert worden ist, wird eine 
// Fehlermeldung ausgegeben.
// Rueckgabewert true oder false

// Input: 	IsArray		=	Bezeichnung des Array Objektes
//			fieldname	=	Feldname des Select Feldes
//			fieldbez	=	Feldbezeichnung des Select Feldes
//			hiddenfield	=	Bezeichnung des Hidden Feldes, in das die selektierten Werte geschrieben wird
//			returnalert	=	Kennzeichen ob Pflichtfeld			

//
// ---------------------------------------------------------------

function CheckMultiselect(IsArray,fieldname,fieldbez,hiddenfield,returnalert)
{


	var IsSelected=false;
	var NewField;
	eval('document.form1.'+hiddenfield+'.value=""');
	for(i = 0; i < eval('document.form1.'+fieldname+'.length'); i++)
	{
	
	
		if(eval('document.form1.'+fieldname+'['+i+'].selected'))
		{
			// HiddenField aufbereiten
			
			if(IsSelected==true && trim(eval('document.form1.'+hiddenfield+'.value')) != '')
			{
				eval('document.form1.'+hiddenfield+'.value=document.form1.'+hiddenfield+'.value+","+'+IsArray+'['+i+']');
			}
			else
			{
				eval('document.form1.'+hiddenfield+'.value=document.form1.'+hiddenfield+'.value+'+IsArray+'['+i+']');
			}
			IsSelected=true;
		}
	}



	if(!IsSelected && returnalert==1)
	{
		alert('Keine Auswahl im Feld ['+fieldbez+']!');
		return false;
	}
	else
	{
		return true;
	}
	
	IsSelected=false;

}


// ---------------------------------------------------------------
//
//	trim
//	@Die Funktion trim uebernimmt einen String entfernt
//	 ggf. vorausstehende sowie anhaengende Blanks und 
//	 gibt den (modifizierten) String wieder zurueck.   
//
// ---------------------------------------------------------------

function trim( str )
{
	var n;
	var i;

	// initialisieren der Blanks vor dem String i entspricht dem ersten Index		 
	for( i = 0; i < str.length; i ++ )
	{
		if( str.charAt( i ) != " ") { break; }
	}
	
	// initialisieren der Blanks nach dem String n entspricht dem zweiten Index	
	for( n = str.length-1; n >= i; n -- )
	{
		if( str.charAt( n ) != " " ) { break; }
	}

	// Ausschneiden des Stringabschnittes	
	str=str.substring( i, n+1 );

	// Rueckgabe des modifizierten Strings   
	return(str);
	
} // trim


// ---------------------------------------------------------------
//
//	stringToDate
//	@Datumseingabe im Format <dd.mm.yy> oder <dd.mm.yyyy> in Date wandeln
//   Leerzeichen zu Beginn und am Ende werden als entfernt vorausgesetzt.
//   Abgedeckt wird der Datumsbereich [01.01.1600 : 31.12.2199]
//   Zweistellige Jahreszahlen werden auf den Bereich [1940-2039] abgebildet
//  @<datum>: zu wandelnder String
//  @return: resultierendes Date-Object
//
// ---------------------------------------------------------------

function stringToDate( datum )
{
	var i, j, str, ch;
	var anzPunkte = 0;
	var len = datum.length;
	var day, month, year;
	var date;

	// ---
	// Konsitenzpuefungen
	// ---
	if( datum.length < 6 || datum.length > 10 )
	{
		alert( "Datum <" + datum + "> hat falsches Format (falsche Laenge )" );
		return( null );
	}
	for( i = 0; i < datum.length; i ++ )
	{
		ch = datum.charAt( i );
		if( ch == '.' )
		{ 
			anzPunkte ++;
		}
		else
		{
			if( ch < '0' || ch > '9' )
			{
				alert( "Datum <" + datum + "> enthaelt das ungueltige Zeichen <" + ch + ">" );
				return( null );
			}
		}
	}
	if( anzPunkte != 2 )
	{
		alert( "Datum <" + datum + "> enthaelt nicht genau zwei Punkte als Trennzeichen." );
		return( null );
	}
	
	// ---
	// Datum scheint gueltig, jetzt in Date-Object wandeln
	// ---
	i = j = 0;
	while( i < len && datum.charAt( i ) != '.' ) { i ++; }
	day = eval( datum.substring( j, i ));
	i = j = i+1;
	while( i < len && datum.charAt( i ) != '.' ) { i ++; }
	month = eval( datum.substring( j, i ));
	year = eval( datum.substring( i+1, len ));

	// ---
	// Letzte, schwache Konsitenzpruefung, die Schaltjahre ausser Acht laesst
	// ---
	if( day < 1 || day > 31 ||
	    day > 29 && month == 2 ||
		day > 30 && ( month == 4 || month == 6 || month == 9 || month == 11 ))
	{
		alert( "Datum <" + datum + "> enthaelt den ungueltigen Tageswert <" + day + ">" );
		return( null );
	}
	if( month < 1 || month > 12 )
	{
		alert( "Datum <" + datum + "> enthaelt den ungueltigen Monatswert <" + month + ">" );
		return( null );
	}
	if( year < 0 || year > 2199 || ( year >= 100 && year < 1600 ))
	{
		alert( "Datum <" + datum + "> enthaelt den ungueltigen Jahresswert <" + year + ">" );
		return( null );
	}

	// Zweistellige Jahreszahlen auf vierstellige abbilden
	if( year < 100 )
	{
		if( year < 40 ) { year += 2000; }
		else            { year += 1900; }
	}

	// Alles OK
	return( new Date( year, month-1, day ));
	
} // stringToDate


// ---------------------------------------------------------------
//
//	checkInteger
//  @Diese Funktion prueft, ob es sich um ganze Zahl handelt
//
// ---------------------------------------------------------------

function checkInteger( Field )
{	
	// Testen, ob ueberhaupt etwas im Feld steht
	if( Field.value != "" )
	{ 
		var FieldChar;

		// Jeden Char prüfen
		for( var i = 0; i < Field.value.length; i++ )
		{
			// Char aus dem String holen
			FieldChar = Field.value.charAt(i);

			// testen, ob der Char im gueltigen Bereich liegt
			if( (FieldChar < "0") || ("9" < FieldChar))
			{ 
				if ( (i==0) && (FieldChar == "-") )
				{	}
				else
				{
					alert("Sie müssen eine ganze Zahl eingeben");
					return false;
				}
			}
		}
	}
	else
	{
		alert("Sie müssen eine ganze Zahl eingeben");
		return false;
	}
	
	// Alles OK
	return true;
	
} // checkInteger


// ---------------------------------------------------------------
//
//	checkIntegerWithRange
//  @Diese Funktion prueft, ob es sich um ganze Zahl handelt, 
//   die in dem Bereich Min bzw. Max liegt
// ---------------------------------------------------------------

function checkIntegerWithRange( Field, Min, Max )
{
	// Testen, ob es eine ganze Zahl ist
	if( checkInteger( Field ) )
	{
		// Den Wert der Zahl ermitteln und auf den Bereich pruefen
		Zahl = eval( Field.value );
		if( (Min <= Zahl) && (Zahl <= Max) )
		{
			return( true );
		}
		else
		{
			alert( "Die Zahl liegt nicht im zulässigen Bereich [" + Min + "," + Max + "]" );
			return false;
		}
	}

	// Error
	return false;
	
} // checkIntegerWithRange


// ---------------------------------------------------------------
//
//	checkFloat
//	@Diese Funktion prueft, ob es sich um Zahl mit , oder . handelt
//	@Ein Komma wird , genau wie ein Punkt, als Nachkommaseparator behandelt
//
// ---------------------------------------------------------------

function checkFloat( Field, MaxNachkommastellen )
{ 
	// Testen, ob ueberhaupt etwas im Feld steht
	if( Field.value != "" )
	{ 
		// zaehlt wieviele Dezimalpunkte gefunden wurden
		var Dezimalpunkte = 0;
		var Nachkommastellen = 0;
		var FieldChar;

		// Jeden Char prüfen
		for( var i = 0; i < Field.value.length; i++ )
		{
			// Char aus dem String holen
			FieldChar = Field.value.charAt(i);
			
			// Optionales Vorzeichen handeln
			if( (i==0) && (FieldChar == "+") && (FieldChar == "-") )
			{ continue;	}

			// testen, ob der Char im gueltigen Bereich liegt
			if( (FieldChar != "." ) && ((FieldChar < "0") || (FieldChar > "9")) )
			{
				// testen, ob ein Dezimalpunkgefunden wurde
				if( (FieldChar == ",") && (Dezimalpunkte == 0)) 
				{
					Dezimalpunkte++;
				}
				else
				{
					alert("Sie müssen eine Zahl eingeben");
					return false;
				}
			}
			else
			{
				if( Dezimalpunkte > 0 )
				{
					Nachkommastellen++;
					if(Nachkommastellen > MaxNachkommastellen) 
					{
						if( MaxNachkommastellen == 1)
						{
							alert("Es ist nur 1 Nachkommastelle erlaubt");
						}
						else
						{
							alert("Es sind nur "+MaxNachkommastellen+" Nachkommastellen erlaubt");
						}
						return false;
					}
				}
			}
		}
	}
	else
	{
		alert("Sie müssen eine Zahl eingeben");
		return false;
	}
	return true;
	
} // checkFloat




// ---------------------------------------------------------------
//
//	checkFloat
//	@Diese Funktion prueft, ob es sich um Zahl mit , oder . handelt
//	@Ein Komma wird , genau wie ein Punkt, als Nachkommaseparator behandelt
//
// ---------------------------------------------------------------

function checkFloatNoMessage( Field, MaxNachkommastellen )
{ 
	// Testen, ob ueberhaupt etwas im Feld steht
	if( Field.value != "" )
	{ 
		// zaehlt wieviele Dezimalpunkte gefunden wurden
		var Dezimalpunkte = 0;
		var Nachkommastellen = 0;
		var FieldChar;

		// Jeden Char prüfen
		for( var i = 0; i < Field.value.length; i++ )
		{
			// Char aus dem String holen
			FieldChar = Field.value.charAt(i);
			
			// Optionales Vorzeichen handeln
			if( (i==0) && (FieldChar == "+") && (FieldChar == "-") )
			{ continue;	}

			// testen, ob der Char im gueltigen Bereich liegt
			if( (FieldChar != "." ) && ((FieldChar < "0") || (FieldChar > "9")) )
			{
				// testen, ob ein Dezimalpunkgefunden wurde
				if( (FieldChar == ",") && (Dezimalpunkte == 0)) 
				{
					Dezimalpunkte++;
				}
				else
				{
					return false;
				}
			}
			else
			{
				if( Dezimalpunkte > 0 )
				{
					Nachkommastellen++;
					if(Nachkommastellen > MaxNachkommastellen) 
					{
						if( MaxNachkommastellen == 1)
						{
							alert("Es ist nur 1 Nachkommastelle erlaubt");
						}
						else
						{
							alert("Es sind nur "+MaxNachkommastellen+" Nachkommastellen erlaubt");
						}
						return false;
					}
				}
			}
		}
	}
	else
	{
		return false;
	}
	return true;
	
} // checkFloat

// ---------------------------------------------------------------
//
//	checkFloatWithRange
//	@Gleitkommazahl auch auf Bereich pruefen
//
// ---------------------------------------------------------------

function checkFloatWithRange( Field, MaxNachkommastellen, Min, Max )
{ 
	if( checkFloat(Field, MaxNachkommastellen) )
	{
		Zahl = eval(Field.value);
	}
	else
	{
		return false;
	}
	
	if( (Min <= Zahl) && (Zahl <= Max) )
	{
		return( true );
	}
	else
	{
		alert("Die Zahl liegt nicht im zulässigen Bereich ( "+Min+", "+Max+" ) ");
		return false;
	}
} // checkFloatWithRange


// ---------------------------------------------------------------
//
//	checkDateInput
//	@Date-Eingabe pruefen
//  @<val>: zu pruefendes Feld
//  @return: <true> bei korrekter Eingabe, <false> sonst
//  @return: <Date> bei korrekter Eingabe, <null> sonst
//
// ---------------------------------------------------------------

function checkDateInput( val )
{
	var value;	// Datumsobject
	
	// Eingabe in Datumsobjekt wandeln
	if( (value  = stringToDate( val.value )) == null )
	{
		return( null );
	}

	// Alles OK
	return( value );
	
} // checkDateInput


// ---------------------------------------------------------------
//
//	changeAbsolutFrame
//	@Neuen Frame setzen (Diese Funktion nicht inlinen!)
//	@Man beachte: Absoluter Bezug mittels <top>
//
// ---------------------------------------------------------------
function changeAbsolutFrame( URL, Target )
{
	top.frames[Target].location.href=URL;
	
} // changeAbsolutFrame


// ---------------------------------------------------------------
//
//	changeFrame
//	@Neuen Frame setzen (Diese Funktion nicht inlinen!)
//	@Man beachte: Relativer Bezug mittels <parent>
//
// ---------------------------------------------------------------
function changeFrame( URL, Target )
{
	parent.frames[ Target ].location.href = URL;
	
} // changeFrame

// ---------------------------------------------------------------
//
//	convertFloat
//	Konvertiert eine Zeichenfolge mit , oder . in ##.##
//
// ---------------------------------------------------------------
function convertFloat( numField )
{
	if(numField == "" ){numField="0.00";}
	numField	=	numField.replace(',','.');
	return( numField )
}


// ---------------------------------------------------------------
//
//	stringToTime
//	@Uhrzeiteingabe im Format <HH:mm>
//  @<datum>: zu wandelnder String
//
// ---------------------------------------------------------------

function stringToTime( patime )
{
	var i, j, str, ch;
	var anzPunkte = 0;


	// ---
	// Konsitenzpuefungen
	// ---
	if( patime.length != 5 )
	{
		alert( "Uhrzeit <" + patime + "> hat falsches Format (falsche Laenge )" );
		return( null );
	}
	for( i = 0; i < patime.length; i ++ )
	{
		ch = patime.charAt( i );
		if( ch == ':' )
		{ 
			anzPunkte ++;
		}
		else
		{
			if( ch < '0' || ch > '9' )
			{
				alert( "Uhrzeit <" + patime + "> enthaelt das ungueltige Zeichen <" + ch + ">" );
				return( null );
			}
		}
	}
	if( anzPunkte != 1 )
	{
		alert( "Uhrzeit <" + patime + "> enthaelt nicht genau einen Doppelpunkt als Trennzeichen." );
		return( null );
	}

	// Alles OK
	return(true);
	
} // stringToTime


function stringToDateTime(paDate,FieldName)
{
	date=trim(paDate.substring( 0, 11 ));
	time=paDate.substring( 11, 16 );
	
	if( paDate.length != 16 && paDate.length != 10 )
	{
		alert( FieldName + " <" + paDate + "> hat falsches Format (falsche Laenge )" );
		return("");
	}
	if( stringToDate(date) == null )
	{
		return("");
	}
	if( paDate.length > 10 )
	{
		if( stringToTime(time) == null )
		{
			return("");
		}
	}
	if( paDate.length == 10 )
	{
		paDate = date + ' 00:00';
	}
	return(paDate);
}

function stz_spaw_replace(str_cont)
{
	if( 
			str_cont == "<P>&nbsp;</P>" 
		||	str_cont == "<p>&nbsp;</p>" 
		)
	{
		str_cont="";
	}
	
	return str_cont
}