function testIt()
{
	alert( "DEBUG: test in standard.js");
	alert( convertFloatToString( -12345.6789, ",", "." ) );

}



// Navigator Resize-Fix
function MM_reloadPage(init) {  //reloads the window if Nav4 resized
if (init==true) with (navigator) {if ((appName=="Netscape")&&(parseInt(appVersion)==4)) {
  document.MM_pgW=innerWidth; document.MM_pgH=innerHeight; onresize=MM_reloadPage; }}
else if (innerWidth!=document.MM_pgW || innerHeight!=document.MM_pgH) location.reload();
}

MM_reloadPage(true);

	// Konvertierungsfunktionen

	function convertStringToFloat( strFloatingPointValue, strDecimalPlaceSeparator, strThousandsSeparator )
		{
		//////////////////////////////////////////////////////////////////////
		// Parameter:                                                       //
		// - strFloatingPointValue    => Fliesskomma-Zahl als String        //
		// - strDecimalPlaceSeparator => Trennzeichen fuer Kommastelle      //
		// - strThousandsSeparator    => Trennzeichen fuer Tausenderstellen //
		//                                                                  //
		// Rueckgabewert:                                                   //
		// - In Flieskomma-Zahl umgewandelter String                        //
		//////////////////////////////////////////////////////////////////////
		
		var strValue = new String;		
		var lngDecimalPlaceSeparator = 0;		

		strValue = trim( strFloatingPointValue );
		
//		alert( "DEBUG: Uebergebener String = " + strValue );

		
		///////////////////////////////
		// Unerlaubte Zeichen entfernen
		for( var i = 0; i < strValue.length; i++ )
			{
			switch( strValue.charAt(i) )
				{
				case "+":	// Positives Vorzeichen
				case "-":	// Negatives Vorzeichen
					{
					if ( i != 0 )	// Nicht an erster Stelle?
						{
						// Unerlaubtes Zeichen wurde gefunden => Entfernen
						strValue = stringCharInStringDelete( strValue, i-- );
						//alert( "Unerlaubtes Zeichen entfernen String = " + strValue );
						}
					}

				case "0":
				case "1":
				case "2":
				case "3":
				case "4":
				case "5":
				case "6":
				case "7":
				case "8":
				case "9":
					// Zeichen OK => Nichts machen
					//alert( "Zeichen "+strValue.charAt(i)+" im String ist OK" );
					break;

				case strDecimalPlaceSeparator:
					lngDecimalPlaceSeparator += 1;	// Anzahl der gefundenen Dezimal-Trennzeichen

					if ( lngDecimalPlaceSeparator > 1 )
						{
						// Mehr als ein Dezimal-Trennzeichen wurde gefunden => Entfernen
						strTemp  = new String;
						strTemp  = strValue.substr( 0, i );
						strTemp += strValue.substr( (i + 1), strValue.length );
						
						strValue = strTemp;
						i--;
						//alert( "Dezimalstelle entfernen String = " + strValue );
						}
					else
						{
						// Kommastellen-Trennzeichen gegen "." austauschen, falls noetig

						if ( strDecimalPlaceSeparator != "." )
							{
							// Kommastellen-Trennzeichen ersetzen
							strTemp = new String;
							strTemp = strValue.substr( 0, i );
							strTemp += ( "." + strValue.substr( (i + 1), strValue.length ) );
							
							strValue = strTemp;
							}
						//alert( "Dezimalstelle entfernen String = " + strValue );
						}
					
					break;

				case strThousandsSeparator:	// Trennzeichen fuer Tausenderstellen entfernen

				default:
					// Unerlaubtes Zeichen wurde gefunden => Entfernen

					strTemp = new String;
					strTemp = strValue.substr( 0, i );
					strTemp += strValue.substr( (i + 1), strValue.length );
					
					strValue = strTemp;
					i--;

					//alert( "Unerlaubtes Zeichen entfernen String = " + strValue );
					
					break;
				}
			}

//		alert( "DEBUG: Bereinigter String = " + strValue );

		// Flieskomma-Zahl zurueckgeben
		return parseFloat( strValue );
		}
	
	
	function convertFloatToString( dblFPValue, strDecimalPlaceSeparator, strThousandsSeparator )
		{
		//////////////////////////////////////////////////////////////////////
		// Parameter:                                                       //
		// - dblFPValue               => Fliesskomma-Zahl                   //
		// - strDecimalPlaceSeparator => Trennzeichen fuer Kommastelle      //
		// - strThousandsSeparator    => Trennzeichen fuer Tausenderstellen //
		//                                                                  //
		// Rueckgabewert:                                                   //
		// - In String umgewandelte Fliesskomma-Zahl                        //
		//////////////////////////////////////////////////////////////////////

		strFPValue = new String;
		strFPValue = String( dblFPValue );
		
//		alert ( "dblFPValue: "+dblFPValue+"\nstrDecimalPlaceSeparator: "+strDecimalPlaceSeparator+"\nstrThousandsSeparator: "+strThousandsSeparator );
//		alert( "FKZ = " + strFPValue );
		
		
		////////////////////////////////////////////////////////////////
		// "." gegen Kommastellen-Trennzeichen austauschen, falls noetig
		if ( strDecimalPlaceSeparator != "." )
			{
			for ( var i = 0; i < strFPValue.length; i++ )
				{
				if ( strFPValue.charAt(i) == "." )
					{
					// Kommastellen-Trennzeichen ersetzen
					strTemp = new String;
					strTemp = strFPValue.substr( 0, i );
					strTemp += ( strDecimalPlaceSeparator + strFPValue.substr( (i + 1), strFPValue.length ) );
					
					strFPValue = strTemp;
					i--;
					}
				}
			}
//		alert( "\".\" durch Kommastellen-Zeichen ersetzt \"" + strDecimalPlaceSeparator + "\" = " + strFPValue );


		//////////////////////////////////////////
		// Tausenderstellen-Trennzeichen einfuegen
		var pos;
		pos = strFPValue.indexOf( strDecimalPlaceSeparator );
		if ( pos == -1 )	// Zeichen nicht gefunden ( = Ganzzahl) ?
			pos = strFPValue.length;

		// Nachkomma-String ermitteln
		strAfterDecimalPlaceSeparator = new String;
		strAfterDecimalPlaceSeparator = strFPValue.substr( pos, strFPValue.length );

		// Vorkomma-String ermitteln
		strBeforeDecimalPlaceSeparator = new String;
		strBeforeDecimalPlaceSeparator = strFPValue.substr( 0, pos );

		var numSep = 0;
		
		if ( strBeforeDecimalPlaceSeparator.length > 3 )
			{
			for( var i = (strBeforeDecimalPlaceSeparator.length - 1); i >= 0; i-- )
				{
				// Tausenderstellen-Trennzeichen einfuegen
				if ( ((strBeforeDecimalPlaceSeparator.length - i - numSep) % 3 == 0) && (i != 0) )
					{
					numSep++;
					
					strBefore = new String;
					strAfter  = new String;
					
					strBefore = strBeforeDecimalPlaceSeparator.substr( 0, i );
					strAfter  = strBeforeDecimalPlaceSeparator.substr( i, strBeforeDecimalPlaceSeparator.length );
					
					strBeforeDecimalPlaceSeparator = strBefore + strThousandsSeparator + strAfter;
					}
				}
			}
		// Gesamt-String zusammensetzen
		strFPValue = strBeforeDecimalPlaceSeparator + strAfterDecimalPlaceSeparator;
		

		// String zurueckgeben
		return strFPValue;
		}


	// Formularfunktionen

	function FormDebugShowElements( objForm )
		{
		//////////////////////////////////////////////////////////////////////
		// Parameter:                                                       //
		// - objForm                => Formular-Objekt                      //
		//                                                                  //
		// Rueckgabewert:                                                   //
		// - keine                                                          //
		//////////////////////////////////////////////////////////////////////
		
		var numElements        = 0;

		var strInfo            = "DEBUG: Formular " + objForm.name + " Info\n";
		var strInfoRadioButton = "DEBUG: Formular " + objForm.name + " Radio-Buttons:\n";
		var strInfoCheckbox    = "DEBUG: Formular " + objForm.name + " Checkbox:\n";
		var strInfoHidden      = "DEBUG: Formular " + objForm.name + " Hidden:\n";
		var strInfoButton      = "DEBUG: Formular " + objForm.name + " Button:\n";
		var strInfoSubmit      = "DEBUG: Formular " + objForm.name + " Submit:\n";
		var strInfoText        = "DEBUG: Formular " + objForm.name + " Text\n";
		var strInfoTextArea    = "DEBUG: Formular " + objForm.name + " Text Area\n";
		var strInfoSelectOne   = "DEBUG: Formular " + objForm.name + " Select One\n";

		while  ( objForm.elements[ numElements ] )		// Existiert Feld in Formular?
			{
			objElement   = objForm.elements[ numElements++ ];		// Formular-Element-Object zuweisen
			switch( objElement.type )
				{
				case "checkbox":	strInfoCheckbox    += "Name: " + objElement.name + "\n"; break;
				case "radio":	    strInfoRadioButton += "Name: " + objElement.name + "\n"; break;
				case "hidden":		strInfoHidden      += "Name: " + objElement.name + "\n"; break;
				case "button":		strInfoButton      += "Name: " + objElement.name + "\n"; break;
				case "submit":		strInfoSubmit      += "Name: " + objElement.name + "\n"; break;
				case "text":		strInfoText        += "Name: " + objElement.name + "\n"; break;
				case "textarea":	strInfoTextArea    += "Name: " + objElement.name + "\n"; break;
				case "select-one":	strInfoSelectOne   += "Name: " + objElement.name + "\n"; break;

				// Nicht ausgewertete Elemente:
				default:			strInfo += "Name: " + objElement.name + " ( " + objElement.type + " )\n";
				}
			}

		alert( strInfo );
		alert( strInfoHidden );
		alert( strInfoSubmit );
		alert( strInfoButton );
		alert( strInfoSelectOne );
		alert( strInfoRadioButton );
		alert( strInfoCheckbox );
		alert( strInfoText );
		alert( strInfoTextArea );

		return ;
		}

	function FormGetElementsByName( objForm, strElementName )
		{
		//////////////////////////////////////////////////////////////////////
		// Parameter:                                                       //
		// - objForm                => Formular-Objekt                      //
		// - strElementName         => Name des Formular-Feldes das         // 
		//                             gesucht wird                         //
		//                                                                  //
		// Rueckgabewert:                                                   //
		// - Array                                                          //
		//   [0] Element-Typ oder false false Name nicht gefunden wurde     //
		//   [1] Anzahl der gefundenen Elemente                             //
		//   [2]-[n] Element-Nummern im Formular mit dem uebergebenen Namen //
		//////////////////////////////////////////////////////////////////////
		
		var numElements        = 0;
		var numFoundElements   = 0;
		var aryResult          = new Array( false );			// Kein Element gefunden vorbesetzen


		while ( objForm.elements[ numElements ] )				// Existiert Feld in Formular?
			{
			objElement = objForm.elements[ numElements ];		// Formular-Element-Object zuweisen

			if ( objElement.name == strElementName )
				{
				if ( numFoundElements == 0 )					// 1. Gefundene Element?
					{
					aryResult[ 0 ] = objElement.type;			// Type des Formular-Elementes
					aryResult[ 1 ] = 0;							// Anzahl der gefundenen Elemente vorbesetzen
					}

				if ( objElement.type != aryResult[ 0 ] )		// Neues Element mit anderem Type?
					alert( "ERROR: FormGetElementsByName\n Element " + strElementName + " in Formular " + objForm.name + " besitzt unterschiedliche Typen!!!" );

				aryResult.push( numElements );					// Element merken
				numFoundElements++;								// Anzahl erhoehen
				}

			numElements++;										// Naechstes Element
			}
		
		aryResult[ 1 ] = numFoundElements;						// Anzahl der gefundenen Elemente setzen

/*
		strDebugInfo = "DEBUG: FormGetElementsByName\n Ergebnis\n\n";
		strDebugInfo += "Formular-Element Typ: " + aryResult[ 0 ] + "\n";
		for( i = 2, k = numFoundElements + 2; i < k; i++ )
			{
			strDebugInfo   += "Name: " + objForm.elements[ aryResult[ i ] ].name + " ( " + objForm.elements[ aryResult[ i ] ].type + " )\n";
			}
		alert( strDebugInfo );
*/

		return aryResult;										// Ergebnis-Array zurueckliefern
		}
	

	function FormCheckRequired( objForm, strRequiredFormName, strFieldNameSeparator, strAlertSeparator, strLanguage )
		{
		//////////////////////////////////////////////////////////////////////
		// Parameter:                                                       //
		// - objForm                => Formular-Objekt                      //
		// - strRequiredFormName    => Name des Formular-Feldes das die     // 
		//                             Informationen der erforderlichen     //
		//                             Felder enthaelt                      //
		// - strFieldNameSeparator  => Trennzeichen fuer Formular-Felder    //
		// - strAlertSeparator      => Trennzeichen fuer Alert-Texte        //
		// - strLanguage            => Sprache der Textausgaben             //
		//                                                                  //
		// Rueckgabewert:                                                   //
		// - true/false wenn alle Eingaben gemacht/nicht gemacht sind       //
		//////////////////////////////////////////////////////////////////////


		switch( strLanguage )			// Standard-Alert-Text je Sprache Festlegen
			{
			case "de":					// Deutsch: = LANG_GERMAN in config.inc.php!!!
				{
				langFormRequiredEmpty	= "Eingabefeld ist erforderlich!\nBitte ausfuellen!"; 
				langFormRequiredSelect	= "Auswahl ist erforderlich!\nBitte Eintrag auswaehlen!"; 
				break;
				}

			case "en":					// Englisch: = LANG_ENGLISH in config.inc.php!!!

			default:					// Alle unbekannten Sprachen
				{
				langFormRequiredEmpty	= "Input field is required!\nPlease fill out!"; 
				langFormRequiredSelect	= "Selection is required!\nPlease select an entry!"; 
				break;
				}
			}

		// FormDebugShowElements( objForm );		

//		alert( "DEBUG: FormCheckRequired( " + objForm.name + ", " + strRequiredFormName + ", " + strFieldNameSeparator + ", " + strAlertSeparator + ", " + strLanguage + " ) " );

// 		alert( "DEBUG: objForm.elements[ " + strRequiredFormName + " ].name = " + objForm.elements[ strRequiredFormName ].name );

		if ( objForm.elements[ strRequiredFormName ] )		// Existiert Feld mit Required Informationen?
			{
// 			alert( "DEBUG: Required-Feld ist vorhanden!!!" );

			aryRequired = objForm.elements[ strRequiredFormName ].value.split( strFieldNameSeparator );

// 			alert( "DEBUG: Anzahl der erforderlichen Formular-Felder = " + aryRequired.length );

			for( i = 0, k = aryRequired.length; i < k; i++ )
				{
				strCheckField      = aryRequired[ i ];			// Zu pruefende Daten
				aryCheckField      = strCheckField.split( strAlertSeparator );
				strCheckFormName   = aryCheckField[ 0 ];		// Formular-Element Name des zu pruefenden Feldes
				strCheckFieldAlert = aryCheckField[ 1 ];		// Alerttext des zu pruefenden Feldes

// 				alert( "DEBUG:\n strCheckFormName: " + strCheckFormName  + "\n strCheckFieldAlert: " + strCheckFieldAlert );

				if ( objForm.elements[ strCheckFormName ] )					// Formular-Element vorhanden?
					{
					// Elemente anhand Namen holen, da es unter einem Namen mehrere Elemente geben kann!!!
					// dann ist objForm.elements[ strCheckFormName ] undefinert wegen Mehrdeutigkeit !!!
					// Beispiel: Radio Button, Checkbox
					// Aufbau des Ergebnis-Arrays
					// [0] ist Typ des Elementes oder false
					// [1] ist Anzahl des Elemente
					// [2]-[n] Nummer(n) der Elemente innerhalb des Formulars
					aryElements = FormGetElementsByName( objForm, strCheckFormName );

//	  				objElement = objForm.elements[ strCheckFormName ];		// Formular-Element-Object zuweisen
					objElement = objForm.elements[ aryElements[ 2 ] ];		// Formular-Element-Object zuweisen


//   					alert( "Teste: " + objElement.name  + "( " + objElement.type + " ): " + objElement.value );
//  					alert( "Teste: " + strCheckFormName  + "( " + aryElements[ 0 ] + " ) " );

					switch( aryElements[ 0 ] )									// Typ des Formular-Elementes
						{
						case "select-one":										// Auswahl-Feld
							{
							if ( objElement.value == "" )						// Leeres Auswahl-Feld
								{
								if ( strCheckFieldAlert == "" )					// Alerttext uebergeben?
									strCheckFieldAlert = langFormRequiredSelect;// Standard-Message setzen
								alert( strCheckFieldAlert );
								objElement.focus();
								return false;
								}
							break;
							}

						case "textarea":
						case "text":
						case "password":
							{
							strContent = objElement.value.replace(/\s/g, "" );	// White space, also \f\n\t\v und Leerzeichen entfernen
							strContent = strContent.replace(/\r/, "" );			// CR entfernen
							if ( strContent == "" )								// Leeres Textfeld?
								{
								if ( strCheckFieldAlert == "" )					// Alerttext uebergeben?
									strCheckFieldAlert = langFormRequiredEmpty;	// Standard-Message setzen
								alert( strCheckFieldAlert );
								objElement.focus();
								return false;
								}
							break;
							}

						case "checkbox":
						case "radio":
							{
							var blnChecked = false;
// 							alert( "DEBUG: \nTeste Formulartyp " + aryElements[ 0 ] );

							for( i = 2, k = aryElements[ 1 ] + 2; i < k; i++ )	// Alle gefundenen Elemente pruefen
								{
								objTest = objForm.elements[ aryElements[ i ] ];
//								alert( "Teste: " + objTest.name  + "( " + objTest.type + " ): " + objTest.value );
								if ( blnChecked == false )	// Wurde ausgewaehlter Radio-Button noch nicht gefunden?
									{
									blnChecked = objTest.checked;	// Status des Elementes holen
									}
								}
							
							if ( blnChecked == false )	// Wurde Radio-Button nicht ausgewaehlt?
								{
								if ( strCheckFieldAlert == "" )					// Alerttext uebergeben?
									strCheckFieldAlert = langFormRequiredSelect;// Standard-Message setzen
								alert( strCheckFieldAlert );
								objForm.elements[ aryElements[ 2 ] ].focus();	// Erste Element auswaehlen
								return false;
								}
							
							break;
							}
							
						default:
							{
							alert( "DEBUG: \nFormulartyp " + aryElements[ 0 ]  + " ( Feld: " + strCheckFormName + " )\nwird noch nicht geprueft!!!" );
							return false;
							}
						}

					}
/* 				else */
/* 					alert( "DEBUG: Required-Feld ist nicht vorhanden!!!" ); */
				}
			}

		return true;
		}


	function FormSelectReset( objForm, strFieldName )
		{
		//////////////////////////////////////////////////////////////////////
		// Parameter:                                                       //
		// - objForm                => Formular-Objekt                      //
		// - strFieldName           => <select>-Element Name                //
		//                                                                  //
		// Rueckgabewert:                                                   //
		// - keine                                                          //
		//////////////////////////////////////////////////////////////////////

		objElement = objForm.elements[ strFieldName ];	// Element holen

// 		alert( "Reset " + objElement.name );
// 		alert( "Selected = " + objElement.selectedIndex );
// 		alert( "Value = " + objElement.value );

		if ( objElement != null )						// Existiert Feld?
			{
			switch ( objElement.type )					// Typ testen
				{
				case "select-one":						// Auswahl-Feld
				case "select-multiple":					// Mehrfach-Auswahlfeld
					{
					objElement.selectedIndex = -1;		// Auswahl zuruecksetzen
					break;
					}

				default:
					alert( "DEBUG: Falsches Objekt-Art in FormSelectReset():\n" +
							"Formular: " + objForm.name + "\n" +
							"Element : " + objElement.name + "\n" +
							"Typ     : " + objElement.type + "\n"
							);

				}
			}
		}


	function FormSelectResetAll( objForm )
		{
		//////////////////////////////////////////////////////////////////////
		// Parameter:                                                       //
		// - objForm                => Formular-Objekt                      //
		//                                                                  //
		// Rueckgabewert:                                                   //
		// - keine                                                          //
		//////////////////////////////////////////////////////////////////////

		var numElements = 0;

		while( objForm.elements[ numElements ] )			// Alle Form-Elemente testen
			{
			objElement = objForm.elements[ numElements ];	// Element holen
			//alert( "Testing " + objElement.name + "\nType = "+ objElement.type );

			switch ( objElement.type )						// Typ testen
				{
				case "select-one":							// Auswahl-Feld
				case "select-multiple":						// Mehrfach-Auswahlfeld
					{
					objElement.selectedIndex = -1;			// Auswahl zuruecksetzen
					break;
					}
				}

			numElements++;
			}

		}


	// Prueffunktionen 

	function checkFloatString( strFloatingPointValue, strDecimalPlaceSeparator, strThousandsSeparator )
		{
		//////////////////////////////////////////////////////////////////////
		// Parameter:                                                       //
		// - strFloatingPointValue    => Fliesskomma-Zahl als String        //
		// - strDecimalPlaceSeparator => Trennzeichen fuer Kommastelle      //
		// - strThousandsSeparator    => Trennzeichen fuer Tausenderstellen //
		//                                                                  //
		// Rueckgabewert:                                                   //
		// - true/false wenn String korrekt ist                             //
		//////////////////////////////////////////////////////////////////////
		
		var strValue = new String;		
		var lngDecimalPlaceSeparator = 0;		
		var blnThousandsSeparatorFound = false;		
		var lngDigitCount = 0;		
		var blnCheckOK = true;		

		strValue = trim( strFloatingPointValue );
		
//		alert( "Uebergebener String = " + strValue );

		if ( strValue == "" )					// Leerstring?
			return( false );					// Format nicht korrekt!!!
		
		for( var i = 0; i < strValue.length; i++ )
			{
//			alert( "Pruefe Zeichen >"+strValue.charAt(i)+"< im String.\nlngDigitCount = " + lngDigitCount );
			switch( strValue.charAt(i) )
				{
				case "+":	// Positives Vorzeichen?
				case "-":	// Negatives Vorzeichen?
					{
					if ( i != 0 )		// Nicht an 1. Stelle?
						{
//						alert( "Fehler: '+/-'-Vorzeichen nicht an erster Stelle" );
						return( false );					// Format nicht korrekt!!!
						}
					break;
					}

				case "0":
				case "1":
				case "2":
				case "3":
				case "4":
				case "5":
				case "6":
				case "7":
				case "8":
				case "9":
					lngDigitCount++;						// Anzahl aufeinanderfolgender Ziffern merken

					if ( blnThousandsSeparatorFound == true )	// Wurde schon ein Tausender-Trennzeichen gefunden?
						{
						if ( lngDigitCount > 3 )				// zu grosser Tausender-Block?
							{
//							alert( "Fehler: Zu grosser Tausender Block >3 Ziffern" );
							return( false );					// Format nicht korrekt!!!
							}
						}

					break;

				case strDecimalPlaceSeparator:				// Trennzeichen fuer Dezimal-Trennzeichen
					{
					if ( blnThousandsSeparatorFound == true )	// Wurde schon ein Tausender-Trennzeichen gefunden?
						{
						if ( lngDigitCount != 3 )				// unvollstaendiger Tausender-Block?
							{
//							alert( "Fehler: Unvollstaendiger Tausender Block (!= 3 Ziffern) vor Dezimalzeichen" );
							return( false );					// Format nicht korrekt!!!
							}
						}

					lngDecimalPlaceSeparator += 1;			// Anzahl der gefundenen Dezimal-Trennzeichen erhoehen

					if ( lngDecimalPlaceSeparator > 1 )		// Mehr als ein Dezimal-Trennzeichen?
						{
//						alert( "Fehler: Zu viele Dezimalzeichen" );
						return( false );					// Format nicht korrekt!!!
						}

					lngDigitCount = 0;						// Ziffernanzahl fuer Tausender-Block-Zaehler ruecksetzen
					break;
					}

				case strThousandsSeparator:					// Trennzeichen fuer Tausenderstellen
					{
					if ( blnThousandsSeparatorFound == true )	// Wurde schon ein Tausender-Trennzeichen gefunden?
						{
						if ( lngDigitCount != 3 )				// unvollstaendiger Tausender-Block?
							{
//							alert( "Fehler: Unvollstaendiger Tausender Block (!= 3 Ziffern) vor Dezimalzeichen" );
							return( false );					// Format nicht korrekt!!!
							}
						}

					blnThousandsSeparatorFound = true;		// Tausender-Trennzeichen gefunden
					lngDigitCount = 0;						// Ziffernanzahl fuer Tausender-Block-Zaehler ruecksetzen

					if ( lngDecimalPlaceSeparator > 0 )		// Schon ein Dezimal-Trennzeichen vorhanden?
						{
//						alert( "Fehler: Tausender-Trennzeichen nach Dezimalzeichen" );
						return( false );					// Format nicht korrekt!!!
						}

					lngThousandsPlaceSeparator += 1;			// Anzahl der gefundenen Dezimal-Trennzeichen erhoehen
					break;
					}

				default:
					// Unerlaubtes Zeichen wurde gefunden
//					alert( "Fehler: Unerlaubtes Zeichen >" + strValue.charAt(i) + "<" );
					return( false );					// Format nicht korrekt!!!
					//alert( "Unerlaubtes Zeichen entfernen String = " + strValue );
					
					break;
				}
			}

		if ( ( lngDecimalPlaceSeparator == 0 ) && ( blnThousandsSeparatorFound == true ) )
			{
			if ( lngDigitCount != 3 )				// unvollstaendiger Tausender-Block?
				{
//				alert( "Fehler: Unvollstaendiger Tausender Block (!= 3 Ziffern)" );
				return( false );					// Format nicht korrekt!!!
				}
			}

//		alert( "OK! \n>" + strFloatingPointValue + "<\n ist ein korrekt formatierter Zahlenstring!" );
		return true;	// Zahl ist formal ok! 
		}


	// String-Funktionen 

	function trim( strText )
		{
		////////////////////////////////////////////////////////////////////////
		// Parameter:                                                         //
		// - strText    => Textstring String                                  //
		//                                                                    //
		// Rueckgabewert:                                                     //
		// - String ohne fuehrende und nachfolgene Whitespaces (' ',\t,\r,\n  //
		////////////////////////////////////////////////////////////////////////
		
//		alert( "DEBUG in trim( " + strText + " )" );
		if ( strText )
	        return strText.replace(/^\s*|\s*$/g,"");
		else	    
	    	return "";
 		}


	function stringCharInStringDelete( strText, lngPos )
		{
		////////////////////////////////////////////////////////////////////////
		// Aufgabe:  Zeichen an Position aus String entfernen                 //
		//                                                                    //
		// Parameter:                                                         //
		// - strText    => Textstring String                                  //
		// - lngPos     => Position im String                                 //
		//                                                                    //
		// Rueckgabewert:                                                     //
		// - String ohne das entfernte Zeichen                                //
		////////////////////////////////////////////////////////////////////////

		var strTemp  = new String;

		strTemp  = strText.substr( 0, lngPos );
		strTemp += strText.substr( (lngPos + 1), strText.length );
		
		alert( "DEBUG: stringCharInStringDelete( " + strText + ", " + lngPos + " ) = " + strTemp );

		return strTemp;
		}


	function stringCharInStringInsert( strText, lngPos, strChar )
		{
		////////////////////////////////////////////////////////////////////////
		// Aufgabe:  Zeichen an Position aus String ersetzen                  //
		//                                                                    //
		// Parameter:                                                         //
		// - strText    => Textstring String                                  //
		// - lngPos     => Position im String                                 //
		//                                                                    //
		// Rueckgabewert:                                                     //
		// - String mit ersetzem Zeichen                                      //
		////////////////////////////////////////////////////////////////////////

		var strTemp  = new String;

		strTemp  = strText.substr( 0, lngPos );
		strTemp += strChar;
		strTemp += strText.substr( lngPos, strText.length );

		alert( "DEBUG: stringCharInStringInsert( " + strText + ", " + lngPos + ", " + strChar + " ) = " + strTemp );

		return strTemp;
		}


	function stringCharInStringReplace( strText, lngPos, strChar )
		{
		////////////////////////////////////////////////////////////////////////
		// Aufgabe:  Zeichen an Position aus String ersetzen                  //
		//                                                                    //
		// Parameter:                                                         //
		// - strText    => Textstring String                                  //
		// - lngPos     => Position im String                                 //
		//                                                                    //
		// Rueckgabewert:                                                     //
		// - String mit ersetzem Zeichen                                      //
		////////////////////////////////////////////////////////////////////////

		var strTemp  = new String;

		strTemp  = strText.substr( 0, lngPos );
		strTemp += strChar;
		strTemp += strText.substr( (lngPos + 1), strText.length );

		alert( "DEBUG: stringCharInStringReplace( " + strText + ", " + lngPos + ", " + strChar + " ) = " + strTemp );

		return strTemp;
		}



	// Berechnungsfunktionen 

	function calcCompoundInterest( fltStartValue, fltPercentPerAnnual, fltYears )
		{
		//////////////////////////////////////////////////////////////////////
		// Aufgabe:  Wert mit Zinseszins-Formel berechnen                   //
		//                                                                  //
		// Parameter:                                                       //
		// - fltStartValue       => Anfangswert                             //
		// - fltPercentPerAnnual => Prozent (Zinsen) pro Jahr               //
		// - fltYears            => Anzahl der Jahre                        //
		//                                                                  //
		// Rueckgabewert:                                                   //
		// - Neuer Wert mit Zinseszins-Formel berechneter Wert              //
		//////////////////////////////////////////////////////////////////////

//		alert( "DEBUG: calcCompoundInterest( " + fltStartValue + ", " + fltPercentPerAnnual + ", " + fltYears + " )" );

		fltlNewValue = fltStartValue * Math.pow( ( 1 + ( fltPercentPerAnnual / 100 ) ), fltYears );			


// 		alert( "DEBUG: " + fltStartValue + " * Math.pow( ( 1 + ( " + fltPercentPerAnnual + " / 100 ) ), " + fltYears + " ) = " + fltlNewValue );

						
		return fltlNewValue;	// Berechneter Wert 
		}


	// Mail funktionen 

/*

	function MailCryptMailTo( strMailTo, objFormEmail, objFormCode )
		{
		//////////////////////////////////////////////////////////////////////
		// Aufgabe:  MailTo verschluesseln wegen Spam-Versender             //
		//           Siehe: http://jumk.de/nospam                           //
		//                                                                  //
		// Parameter:                                                       //
		// - strMailTo      => MailTo String (Adresse+Parameter             //
		//                                                                  //
		// Rueckgabewert:                                                   //
		// - Neuer Wert mit Zinseszins-Formel berechneter Wert              //
		//////////////////////////////////////////////////////////////////////
        var n = 0;
        var r = "";
        var s = "mailto:"+strEmailAdress;
        var e = strEmailAdress;

        e = e.replace( /@/, " [at] ");
        e = e.replace( /\./g, " [dot] ");

        for( var i=0; i < s.length; i++ )
        {
            n = s.charCodeAt( i );
            if( n >= 8364 )
            {
                n = 128;
            }
            r += String.fromCharCode(n+1);
        }

        objFormEmail.value = r;
        objFormCode.value = "<a href=\"javascript:MailCallUnCryptMailto('"+ r +"');\">"+ e +"</a>";
		}




    function MailUnCryptMailto( s )
    {
        var n = 0;
        var r = "";
        for( var i = 0; i < s.length; i++)
        {
            n = s.charCodeAt( i );
            if( n >= 8364 )
            {
                n = 128;
            }
            r += String.fromCharCode( n - 1 );
        }
        return r;
    }


    function MailCallUnCryptMailto( strCryptedEmailAdress, strParameter )
    {
        location.href=MailUnCryptMailto( strCryptedEmailAdress );
    }

*/