//	Routinen oder Algorithmen allgemeiner Art, die für mehrere
//	html-Dateien oder Projekte gebraucht werden können.
//	Letzte Bearbeitung:			19.02.09
//	Historie:
//	19.01.09, LG:	GGA in LIAG
//	19.02.09, LG:	tooltip-Routinen hinzugefügt
//					Abfrage. ob Statusleiste aktiviert ist, 
//					Versionsnummer für Internet Explorer abfragen
//
//	1.	Routinen zum Aufruf von html und php-Dateien mit Parametern
//		für Get-Methode
//		--	PHPAufuf			Dateiname mit Parametern für Get-Methode dekodieren
//	 	--	rawurlencode		Zeichen für GET-Methode kodieren
//	 	--	simpleHexCode		ASCII-Zeichen in 2-stelligen HexCode darstellen
//		--	rawurldecode		Umkehrung zu rawurlencode
//		--	HexCodeInDecimal	Hexadecimalzahl (String) in Dezimalzahl umwandeln

function PHPAufruf(scriptname,paramAnzahl,WinObjStr,SyncName)
{
//	Dekodieren von Parameter für GET-Methode
//	und Aufruf des Scripts <scriptname> -wenn nötig mit php-Extension- im
//	Fenster WindowObj.location.href   .
//	Die zu den n Eingabewerten gehörenden Variablen
//	param1, param2 ... paramn werden automatisch erzeugt (s. Beispiel).
//	------------------------------------------------------------------
//	Letzte Änderung:			24.02.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Parameter:
//	Eingabe:
//	scriptname	--	Filename des Scripts.
//					Wenn Filename keine Extension hat, wird automatisch
//					.php angehängt.
//	paramAnzahl	--	max. Anzahl der zu bearbeitenden Eingabewerte
//					-1:	Alle Werte werden bearbeitet.
//	WinObjStr	--	Object:=>	Fenster oder Frame, in das Script
//								geladen werden soll.
//					String:=>	Fenstername für neues zu öffendes Fenster
//								= "": Fenstername = "blank".
//	SyncName	--	Parametername zum Setzen von Synchronistationsinformationen
//					z. B. wie hier "ready", wenn PHP Script ausgeführt hat.
//					Sonderfall, wenn WinObjStr String ist:
//					 = "": "Nullfenster wird geöffnet.
//					!= "": Kleines Fenster (width=200,height=200) wird geöffnet

//	optionale Parameter:
//	Eingabewerte für Script

//	Ausgabe:
//	Return-Werte:
//		<0: Fehler
//			-1:	Argumentanzahl < 4
//			-2:	scriptname ist kein String
//			-3:	Länge von <scriptname> ist 0, (also keine Datei spezifiziert).
//			-4:	WinObjStr muss entweder Objekt (=Fenster oder Frame) oder
//				Name (=String) für neues zu öffendes Fenster sein. 
//			-5:	Textlänge für GET-Methode ist größer 2000 Zeichen.
//				PHP akzeptiert für GET-Methode nur 2k-Zeichen!!!
//		=1:	Aufruf abgesetzt
//
//	Anmerkung: 	Zur Synchronisation mit dem aufrufenden (z. B. aus Javascript)
//				und gerufenen Programm (PHP-Script) wird eine Formularvariable
//				benötigt.
//				Es wird deshalb nach dem letzten Wert der String 
//				...  + SyncName + '=""'
//				hinzugefügt	und <SyncName> als Formularvariable aufgefasst.
//				Das aufgerufene PHP-Script kann	diese dann nach Ausführung
//				(z. B. mit "ready") besetzen. Das rufende Programm fragt in
//				Zeitabständen (z. B. 0.1sec) diesen Formularwert ab und kann
//				so feststellen, ob das	PHP-Script notwendige Daten in einem
//				Fenster übergeben hat.
//	Beispiel:	Aufruf von PHPAufruf("hugo",-1,parent.aus,"gesetzt",wert1,wert2,wert99)
//				ergibt:	parent.aus.location.href =
//						"hugo.php?param1=wert1&param2=wert2&param3=wert99&gesetzt="""

	var text, i, undz, panz, ext, kpstart;
	var argtext;
	var WindowObj, Fenstername, Fensterparam;
	
//	Fehler
	if (arguments.length < 4){
		return -1;
	}

	if (typeof(scriptname) != "string"){
		return -2;
	}

	if (scriptname.length == 0){
		return -3;
	}

	if (typeof(WinObjStr) != "string" && typeof(WinObjStr) != "object"){
		return -4;
	}
	
//	Dekodierung	
	panz = paramAnzahl;
	if (panz < 0) panz = arguments.length-4;
	if (panz > arguments.length-4){
		panz = arguments.length-4;
	}

	text = "";
	undz = "?";
	if (panz > 0){
		for (i=1;i<=panz;i++){
			argtext = arguments[3+i] ;
			argtext = rawurlencode(argtext);
			text = text + undz + "param" + i + "=" + argtext;
			undz = "&"
		}
	}
	if (SyncName != "")	text = text + undz + SyncName + '=' + rawurlencode('""');
//	alert("vor Ext.: " + text);

//	Extension (.-Abfrage) vorhanden?
//	Sonst Anhängen von .php
//	Suchen von / oder \ als letzten Begrenzer für Verzeichnis
	kpstart = 0;
	for(i=scriptname.length-1;i>=0;i--){
		if (scriptname.substr(i,1) == "/" || scriptname.substr(i,1) == "\\" ) {
			kpstart = i;
			break;
		}
	}
	
//	Punkt (.) nur bis / oder \ suchen (Index in kpstart)
	ext = false;
	for(i=scriptname.length-1;i>kpstart;i--){
		if (scriptname.substr(i,1) == ".") {
			ext = true;
			break;
		}
	}

	if (ext){	
		text = scriptname + text;
	}
	else{
		text = scriptname + ".php" + text;
	}
//	alert("PHP-Get-Länge: " + scriptname + ":" + text.length);
//	alert("nach Ext.: " + text);

	if (text.length > 2000){
		alert("Anzahl Zeichen (=" + text.length + ") >2k-Byte für GET-Methode");
		return -5;
	}

	if (typeof(WinObjStr) == "string"){
//	Neues Fenster erstellen und laden bzw. in bestehendes Fenster oder Frame
//	laden, s. Programmbeschreibung
//	Es wird zunächst ein kleines Fenster erstellt, im PHP-Script kann dieses
//	dann entsprechend modifiziert werden.
		Fenstername = WinObjStr;
		if (Fenstername == "" ) Fenstername = "blank";
		Fensterparam = "width=200,height=200,scrollbars,resizable,dependent=yes";
		if (SyncName == "")
				Fensterparam = "width=1,height=1,dependent=yes";
 
 			WindowObj = window.open(text,Fenstername,Fensterparam);

//		alert("testwindow ist open");
	}
	else{
		WindowObj = WinObjStr;
	 	WindowObj.location.href = text;
	}
	return 1;
}

function rawurlencode(uristr)
{
//	Sonderzeichen mit dez. ASCII-Wert <= 32 oder > 122 oder (>=42 && <=46)
//	mit %XX (XX=Hexadezimaler ASCII-Wert) kodieren.
//	Wird für Aufruf in GET-Methode benötigt.
//	Beispiel: abc 1.;  => abc%201			.
//	------------------------------------------------------------------
//	Letzte Änderung:			01.12.2003
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Parameter:
//	Eingabe:
//	uristr			--	zu dekodierender String
//	Ausgabe:
//	Return-Wert:
//	rawurlencode	--	kodierter String

	var neuuri, sz, iw;
	var i;

	uristr = uristr.toString();
//	alert(uristr.length);
	neuuri = "";
	for (i=0;i<uristr.length;i++){
		sz = uristr.substr(i,1);
		iw = sz.charCodeAt(0);
//		alert(i + "/" + sz + "/" + iw);
		if (iw <=32 || iw > 122
				|| (iw <= 44) || (iw == 47) || (iw > 57 && iw <= 64)
				|| (iw > 90 && iw <= 94) || (iw == 96)){
			neuuri = neuuri + "%" + simpleHexCode(iw);
		}
		else{
			neuuri = neuuri + sz;
		}
	}
	return neuuri;
}

function simpleHexCode(dez)
{
//	8-Bit Zahl (dez. 0-255) in 2-stellige Hexadezimalzahl kodieren
//	------------------------------------------------------------------
//	Letzte Änderung:			01.12.2003
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Parameter:
//	Eingabe:
//	dez				--	Dezimalzahl (0<=dez<256)
//	Ausgabe:
//	Return-Wert:
//	simpleHexCode	--	2-stellige Hexadezimalzahl (0<=simpleHexCode<FF)
//	Beispiel:	27 => 1B, 50 => 32.

	var werta = new Array(2);
	var hexarray = new Array("0","1","2","3","4","5","6","7","8","9",
							 "A","B","C","D","E","F");
	var i, j, hx;

	werta[1] = Math.floor(dez/16);
	werta[0] = dez-werta[1]*16;
//	alert(dez + "/" + werta[1] + "/" + werta[0]);
	hx = "";
	for(i=1;i>=0;i--){
		for (j=0;j<16;j++){
			if (werta[i] == j){
				hx = hx + hexarray[j];
//	alert("hx: " + hx);
				break;
			}
		}
	}

	return hx;
}
function rawurldecode(uristr)
{
//	In Hex-Code nach %-Zeichen dargestelltes ASCII-Zeichen wird wieder in
//	ASCII-Zeichen umgewandelt. Umkehrung von rawurlencode.
//	Wird für Verarbeitung des Get-Strings benötigt.
//	Beispiel: abc%201  => abc 1.;			.
//	------------------------------------------------------------------
//	Letzte Änderung:			07.08.2005
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Parameter:
//	Eingabe:
//	uristr			--	zu dekodierender String
//	Ausgabe:
//	Return-Wert:
//	rawurldecode	--	kodierter String

	var neuuri, sz, iw;
	var i;

//	uristr = uristr.toString();
	neuuri = "";
	for (i=0;i<uristr.length;i++){
		sz = uristr.substr(i,1);
		if (sz == "%"){
			iw = uristr.substr(i+1,2);
			neuuri = neuuri + String.fromCharCode(HexCodeInDecimal(iw));
			i=i+2;
		}
		else{
			neuuri = neuuri + sz;
		}
	}
	return neuuri;
}

function HexCodeInDecimal(hex)
{
//	2-stellige Hexadezimalzahl (String) in Dezimalzahl (Integer)
//	kodieren
//	------------------------------------------------------------------
//	Letzte Änderung:			07.08.2005
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Parameter:
//	Eingabe:
//	hex					--	Hexadezimalzahl als String (max. 7FFF)!!
//	Ausgabe:
//	Return-Wert:
//	HexCodeInDecimal	--	Dezimalzahl als Integer (max. 32767)
//	Beispiel:	'1B' => 27, '32' => 50, '7FFF' = 32767.

	var hexarray = new Array("0","1","2","3","4","5","6","7","8","9",
							 "A","B","C","D","E","F");
	var i, j, iw, dez, fak, found;

//	hex = hex.toString();
	hex = hex.toUpperCase();
	fak = 1;
	dez = 0;


	for(i=hex.length-1;i>-1;i--){
		found = false;
		iw = hex.substr(i,1);
		for(j=0;j<16;j++){
			if (iw == hexarray[j]){
				found = true;
				break;
			}
		}
		if (found){
			dez = dez + j*fak;
			fak = fak*16;
		}
		else{
//			Fehler, Es dürfen nur die Zeichen 0-9,A-F (a-f) vorkommen
			return -1;

		}
	}

	return dez;
}


//	-------------------------------------------------------------------------------------
//	2.	Grad, Minute, Sekunde Behandlungsroutinen
//		--	gms_in_grad2	(Grad),(Grad,Minute),(Grad,Minute,Sekunde)-> Alt/Neugrad
//		--	grad_in_gms2	Umkehrung zu gms_in_grad2	
//		--	gms_in_Codegrad	wie gms_in_grad2, aber als kodierte Fliesskommazahl
//		--	Codegrad_in_gms	Umkehrung zu gms_in_Codegrad	
//		--	runden_gms2		Runden oder Abschneiden bei versch. GMS-Darstellungen
//		--	read_gmstext	Text-GMS in 3-dim Feld für Grad, Minute, Sekunde umwandeln
//		--	write_gmstext	Umkehrung zu read_gmstext

function gms_in_grad2(G, min, sec, i)
{
//	Gradumwandelroutine von Dezimalgrad, Grad+Dezimalmiute usw. in Dezimalgrad
//	Eingabe in Altgrad oder Neugrad (s.u.)
//	------------------------------------------------------------------
//	Letzte Änderung:			30.12.2003
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	G	--  Dezimalgrad oder fester Gradanteil oder Fliesskommazahl
//			bei kodierter Darstellung
//	min	--  Dezimalminute oder NaN
//	sec	--  Dezimalsekunde oder NaN
//	i	--  Kodierter Darstellungs- und Unwandelparameter mit 2 Stellen
//			Einerstelle:
//			i = y0: Graddezimal in Graddezimal
//			i = y1: Grad, Min.dezimal in Graddezimal
//			i = y2: Grad, Min, Sek.dezimal in Graddezimal
//			i = y3: Graddezimal in kodierter Form als Fliesskommazahl
//					(Beispiel: 23.12 = 23.12, also wie i=0)
//			i = y4: Grad, Min.dezimal in kodierter Form als Fliesskomma-
//					zahl (Beispiel: 23 01.2= 2301.2)
//			i = y5: Grad, Min. Sek.dezimal in kodierter Form als Fliess-
//					zahl (Beispiel: 23 12 13.123= 231213.123).
//			Anm.:   Für yi>2, s. a. codegrad_in_gms und gms_in_codegrad,
//					y=Zehnerstelle
//			Zehnerstelle:
//			i = 0x:	Altgrad in Altgrad
//			i = 1x:	Neugrad in Neugrad
//			i = 2x:	Altgrad in Neugrad
//			i = 3x:	Neugrad in Altgrad
//					x ist Einerstelle (s.o.)
//	Ausgabe:
//	Function-return
//	gms_in_grad2  --	Dezimalgrad (Alt oder Neugrad)
//				Fehler:
//				-9000000:	Anzahl Argumente ungleich 4.
//				-9000001:	i nicht im Bereich:	 0<=i<= 5,     10<=i<=15,
//												20<=i<=25 oder 30<=i<=35.
//				-9000002:	G	enthält Fehlercode (<=-9000000).
//				-9000003:	G	keine Zahl (NaN) bei i=0,3,10,13,20,23,30,33.
//				-9000004:	min keine Zahl (NaN) bei i=1,4,11,14,21,24,31,34.
//				-9000005:	sec keine Zahl (NaN) bei i=2,5,12,15,22,25,32,35.
//				-9000006:	abs(min) >  60 bei i= 1, 2, 4, 5,21,22,24,25 oder
//							abs(min) > 100 bei i=11,12,14,15,31,32,34,35
//				-9000007:	abs(sec) >  60 bei i=    2,    5,   22,   25 oder
//							abs(sec) > 100 bei i=   12,   15,   32,   35
//	Beispiel:	G=23, min=12, sec=24.1 ergibt bei:
//			    i=0:  23, i=1: 23.2, i=2:  23.206694444444444,
//				i=20: 25.55555555555555 (gon), i=22: 25.78521604938272 (gon)

	var w, v;
	var argnum;
	var gms_i, an_i, grfak, grmax, grad_gon;

//	Fehlerabfragen bei Eingang
//	Argumentanzahl
	argnum = arguments.length;
	if (argnum != 4) return -9000000;
	
	i	= parseInt(i);

//	gültige Umwandlungsmodi ?
	an_i	= Fix(i/10)*10;
	gms_i	= i-an_i;
	if (an_i < 0 || an_i > 30 || gms_i < 0 || gms_i > 5) return -9000001;

	G	= parseFloat(G);
	min	= parseFloat(min);
	sec	= parseFloat(sec);

//	Eingabe ist Zahl?
	if (isNaN(G)) return -9000003;

//	Eingabewert (Gradzahl) ist gültig, d.h. ist kein Fehlercode
//	z.B. durch vorherige Umrechnung ?
	if (G <= -9000000)	return -9000002;

//	Umrechnung in Grad, Minute, Sekunde, falls kodierte Fliesskommazahl
//	eingegeben wurde.
	if (gms_i > 2){
		gms_i = gms_i-3;
		GMS = codegrad_in_gms(G,gms_i);

		G	= GMS[0];
		min = GMS[1];
		sec = GMS[2];
	}

	switch(an_i){
	case  0 :
//	Altgrad in Altgrad
		grfak	 =   1.;
		grad_gon =  60.;
		grmax	 = 360.;
		break;

	case 10 :
//	Neugrad (oder Gon) in Neugrad
		grfak	 =   1.;
		grad_gon = 100.;
		grmax	 = 400.;
		break;

	case 20 :
//	Altgrad in Neugrad
		grfak	 = 400./360.;
		grad_gon =  60.;
		grmax	 = 360.;
		break;

	case 30 :
//	Neugrad oder Gon in Altgrad
		grfak	 = 360./400.;
		grad_gon = 100.;
		grmax	 = 400.;
		break;

	}

	switch(gms_i){
	case 0 :
 //	Dezimalgrad in Dezimalgrad
 //	(ggf. Umrechnung von Alt- in Neu- bzw. Neu- in Altgrad)
   	w = G*grfak;
		break;

	case 1 :
//		Minute ist Zahl ?
    	if (isNaN(min))	return -9000004;

//		Minute ist <60 bzw. <100 ?
		if (Math.abs(min) >= grad_gon) return -9000006;
		
    	v = sgn(G);
//		Vorzeichenüberhang bei G=0°
    	if (G == 0) v = sgn(min);

//		in Graddezimal (Alt- oder Neugrad) und Umrechnung in Neu- oder Altgrad
    	w = v * (Math.abs(G) + Math.abs(min)/grad_gon)*grfak;
		break;

	case 2 :
//		Minute ist Zahl ?
    	if (isNaN(min))	return -9000004;

//		Sekunde ist Zahl ?
    	if (isNaN(sec))	return -9000005;

//		Minute ist <60 bzw. <100 ?
		if (Math.abs(min) >= grad_gon) return -9000006;

//		Sekunde ist <60 bzw. <100 ?
		if (Math.abs(sec) >= grad_gon) return -9000007;

    	v = sgn(G);
//		Vorzeichenüberhang bei G=0° ?
    	if (G == 0){
        	v = sgn(min);
//			Vorzeichenüberhang bei min=0' ?
        	if (min == 0) v = sgn(sec);
    	}

//		in Graddezimal (Alt- oder Neugrad) und Umrechnung in Neu- oder Altgrad
    	w = v * (Math.abs(G) + Math.abs(min)/grad_gon + Math.abs(sec)/(grad_gon*grad_gon))*grfak;
		break;

	}

	return  w;

}


function grad_in_gms2(grad, i)
{
//	Umwandelroutine von Dezimalgrad in Dezimalgrad oder Grad, Dezimalminute oder
//	Grad, Minute, Dezimalsekunde in Alt- oder Neugrad oder in kodierter Form
//	------------------------------------------------------------------
//	Letzte Änderung:			30.12.2003
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	grad	--	Dezimalgrad oder kodierte Fliesskommazahl
//				NaN: keine Umwandlung
//	i		--  Kodierter Darstellungs- und Unwandelparameter mit 2 Stellen
//				Einerstelle:
//				i = y0: Graddezimal in Graddezimal
//				i = y1: Grad, Min.dezimal in Graddezimal
//				i = y2: Grad, Min, Sek.dezimal in Graddezimal
//				i = y3: Graddezimal in kodierter Form als Fliesskommazahl
//						(Beispiel: 23.12 = 23.12, also wie i=0)
//				i = y4: Grad, Min.dezimal in kodierter Form als Fliesskomma-
//						zahl (Beispiel: 23 01.2= 2301.2)
//				i = y5: Grad, Min. Sek.dezimal in kodierter Form als Fliess-
//						zahl (Beispiel: 23 12 13.123= 231213.123).
//				Anm.:   Für yi>2, s. a. codegrad_in_gms und gms_in_codegrad,
//						y=Zehnerstelle
//				Zehnerstelle:
//				i = 0x:	Altgrad in Altgrad
//				i = 1x:	Neugrad in Neugrad
//				i = 2x:	Altgrad in Neugrad
//				i = 3x:	Neugrad in Altgrad
//						x ist Einerstelle (s.o.)
//	Ausgabe in Feld GMS:
//	GMS[0]	--	Dezimalgrad bei yi=0 oder Grad bei yi=1 und yi=2
//	GMS[1]	--	Dezimalminute bei yi=1 oder Minute bei yi=2
//	GMS[2]	--	Dezimalsekunde bei yi=2
//				Fehler:
//				-9000000:	Anzahl Argumente ungleich 2.
//				-9000001:	i nicht im Bereich:	 0<=i<= 5,     10<=i<=15,
//												20<=i<=25 oder 30<=i<=35.
//				-9000002:	grad enthält Fehlercode (<=-9000000).
//				-9000003:	grad keine Zahl (NaN).
//	Besonderheit:	Ist bei yi=1 oder yi=2 Grad bzw. Grad und/oder Minute 0.0,
//					wird das Vorzeichen auf die Dezimalminute bzw. Minute oder
//					Dezimalsekunde übertragen.
//					Z. B. ist: -0.10 Grad bei i=1: 0  -6.0
//					-0.01 Grad bei i=1: 0  -0,6; bei i=2: 0  0 -36.0
//					Beispiele: grad=23.12 (Eingabe:i=10, Neugrad) ergibt bei
//					Ausgabe mit i=12: 23 12 00 (Neugrad); i=32: 20 48 28.8 (AltGrad);
//					i=30: 20.808 (Grad)

	var w, G, min, sec ;
	var argnum;
	var grad_gon, grmax, grfak, codegr;
    var GMS = new Array(3);

	GMS[0] = NaN;
	GMS[1] = NaN;
	GMS[2] = NaN;

//	Fehlerabfragen bei Eingang
//	Argumentanzahl
	argnum = arguments.length
	if (argnum != 2){
		GMS[0] = -9000000;
		return GMS;
	}

//	gültige Umwandlungsmodi ?
	i		= parseInt(i);
	an_i	= Fix(i/10)*10;
	gms_i	= i-an_i;
	if (an_i < 0 || an_i > 30 || gms_i < 0 || gms_i > 5){
		GMS[0] = -9000001;
		return GMS;
	}


	grad	= parseFloat(grad);
//	Eingabe ist Zahl?
	if (isNaN(grad)){
		GMS[0] = -9000003;
		return GMS;
	}

//	Eingabewert (Gradzahl) ist gültig, d.h. ist kein Fehlercode
//	z.B. durch vorherige Umrechnung ?
	if (grad <=  -9000000){
		GMS[0] = -9000002;
		return GMS;
	}

	switch(an_i){
	case  0 :
//	Altgrad in Altgrad
		grfak	 =   1.;
		grad_gon =  60.;
		grmax	 = 360.;
		break;

	case 10 :
//	Neugrad (oder Gon) in Neugrad
		grfak	 =   1.;
		grad_gon = 100.;
		grmax	 = 400.;
		break;

	case 20 :
//	Altgrad in Neugrad
		grfak	 = 400./360.;
		grad_gon = 100.;
		grmax	 = 400.;
		break;

	case 30 :
//	Neugrad oder Gon in Altgrad
		grfak	 = 360./400.;
		grad_gon =  60.;
		grmax	 = 360.;
		break;

	}


	G = NaN;
	min = NaN;
	sec = NaN;

	grad = grad*grfak;

	codegr = false;
	if (gms_i > 2){
		gms_i = gms_i-3;
		codegr = true;
	}


	switch(gms_i){
//	Dezimalgrad in Dezimalgrad
	case 0 :
    	G = grad;
		break;

//	Dezimalgrad in Grad, Dezimalminute
	case 1 :
    	G = Fix(grad);
    	min = Math.abs((grad - G)) * grad_gon;
    	if (G == 0) min = sgn(grad) * min;
		break;

//	Dezimalgrad in Grad, Minute, Dezimalsekunde
	case 2 :
    	G = Fix(grad);
    	w = Math.abs((grad - G)) * grad_gon;
    	min = Fix(w);
    	sec = (w - min) * grad_gon;
    	if (G == 0){
       		min = sgn(grad) * min;
       		if (min == 0) sec = sgn(grad) * sec;
    	}
		break;

	}

	if (!codegr){
		GMS[0] = G;
		GMS[1] = min;
		GMS[2] = sec;
	}
	else{
		GMS[0] = gms_in_codegrad(G,min,sec,gms_i);
	}

	return GMS;
}

function gms_in_codegrad(G, min, sec, i)
{
//	Gradumwandelroutine für kodierte Speicherung
//	------------------------------------------------------------------
//	Letzte Änderung:			30.12.2003
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	i = 0:	Umwandeln	von Graddezimal in kodiertem Graddezimal
//									(GG.GGGGG)(keine Berechnung nötig)
//	i = 1:				von Grad, Min.-dezimal in kodiertem
//									Grad, Min.-dezimal (GGMM.MM)
//	i = 2:				von Grad, Min, Sek.-dezimal in kodiertem
//									Grad, Min, Sek.-dezimal (GGMMSS.SS)
//	gms_in_codegrad = Kodierte Gradzahl oder Fehlercode.
//					Fehler:
//					-9000000:	Anzahl Argumente ungleich 4.
//					-9000001:	i nicht im Bereich:	 0<=i<=2.
//					-9000002:	grad enthält Fehlercode (<=-9000000).
//					-9000003:	G	keine Zahl (NaN).
//					-9000004:	min keine Zahl (NaN).
//					-9000005:	sec keine Zahl (NaN).

	var w, v;
	var argnum;

//	Fehlerabfragen bei Eingang
//	Argumentanzahl
	argnum = arguments.length
	if (argnum != 4) return -9000000;

//	gültige Umwandlungsmodi ?
	i = parseInt(i);
	if (i < 0 || i > 2) return -9000001;

	G	= parseFloat(G);
//	Eingabe ist Zahl?
	if (isNaN(G)) return -9000003;

//	Eingabewert (Gradzahl) ist gültig, d.h. ist kein Fehlercode
//	z.B. durch vorherige Umrechnung ?
	if (G <= -9000000) return -9000002;
	
	min	= parseFloat(min);
	sec	= parseFloat(sec);

	switch(i){
//	Dezímalgrad (10.123°=10.123) als kodierte Fliesskommazahl
	case 0 :
		w = G;
		break;

//	Grad und Dezimalminute(10° 59.99'=1059.99) als kodierte Fliesskommazahl
	case 1 :
//		Minute ist Zahl?
		if (isNaN(min)) return -9000004;

		v = sgn(G);
//		Vorzeichenüberhang auf Minute, falls G=0° ist.
		if (G == 0) v = sgn(min);
		w = v * (Math.abs(G) * 100 + Math.abs(min));
		break;

//	Grad, Minute, Dezimalsekunde als kodierte Fliesskommazahl(10° 1' 10.123"=100110.123) 
	case 2 :
//		Minute ist Zahl?
		if (isNaN(min)) return -9000004;

//		Sekunde ist Zahl?
		if (isNaN(sec)) return -9000005;

		v = sgn(G);
		if (G == 0){
//			Vorzeichenüberhang auf Minute, falls G=0° ist.
			v = sgn(min);
//			Vorzeichenüberhang auf Sekunde, falls min=0' ist.
			if (min == 0)	v = sgn(sec);

		}
		w = v * ((Math.abs(G) * 100 + Math.abs(min)) * 100 + Math.abs(sec));
		break;


	}
	return w;

}

function codegrad_in_gms(wert, i)
{
//	Umwandeln von kodierten Gradzahlen
//	------------------------------------------------------------------
//	Letzte Änderung:			30.12.2003
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	i = 0:	Umwandeln	von kodiertem Graddezimal (GG.GGGGG)
//								in Graddezimal (keine Berechnung nötig)
//	i = 1:				von Kodiertem Grad, Min.-dezimal (GGMM.MM)
//								in Grad, Min.-dezimal
//	i = 2:				von kodiertem Grad, Min, Sek.-dezimal (GGMMSS.SS)
//								in Grad, Min, Sek.-dezimal
//	min oder sec = NaN, wenn sie nicht benutzt werden, abhängig von i
//	g = NaN, wenn Eingabewert NaN ist oder i ungültig ist.
//					Fehler:
//					-9000000:	Anzahl Argumente ungleich 2.
//					-9000001:	i nicht im Bereich:	 0<=i<=2.
//					-9000002:	grad enthält Fehlercode (<=-9000000).
//					-9000003:	wert keine Zahl (NaN).

	var w, G, min, sec;
	var argnum;
    var GMS = new Array(3)

	GMS[0] =NaN;
	GMS[1] =NaN;
	GMS[2] =NaN;
	
//	Fehlerabfragen bei Eingang
//	Argumentanzahl
	argnum = arguments.length
	if (argnum != 2){
		GMS[0] = -9000000;
		return GMS;
	}
	
//	gültige Umwandlungsmodi ?
	i = parseInt(i);
	if (i < 0 || i > 2){
		GMS[0] = -9000001;
		return GMS;
	} 

//	Eingabe ist Zahl?
	wert	= parseFloat(wert);
	if (isNaN(wert)){
		GMS[0] = -9000003;
		return GMS;
	}


//	Eingabewert (Gradzahl) ist gültig, d.h. ist kein Fehlercode
//	z.B. durch vorherige Umrechnung ?
	if (wert <= -9000000){
		GMS[0] = -9000002;
		return GMS;
	}

    min = NaN;
    sec = NaN;
    G 	= NaN;


	switch(i){
//	kodierte Fliesskommazahl in Dezímalgrad (10.123=10.123°)
	case 0 :
    	G = wert;
		break;

//	kodierte Fliesskommazahl als Grad und Dezimalminute(1059.99=10° 59.99')
	case 1 :
    	G = Fix(wert / 100);
    	min = Math.abs((wert - G * 100));
//		Vorzeichenüberhang auf Minute, falls G=0° ist.
    	if (G == 0) min = sgn(wert) * min;
		break;

//	kodierte Fliesskommazahl als Grad, Minute, Dezimalsekunde (100110.123=10° 1' 10.123") 
	case 2 :
    	G = Fix(wert / 10000);
    	w = Math.abs((wert - G * 10000));
    	min = Fix(w / 100);
    	sec = (w - min * 100);
    	if (G == 0){
//			Vorzeichenüberhang auf Minute, falls G=0° ist.
       		min = sgn(wert) * min;
//			Vorzeichenüberhang auf Sekunde, falls min=0' ist.
       		if (min == 0) sec = sgn(wert) * sec;
    	}
		break;


	}

	GMS[0] = G;
	GMS[1] = min;
	GMS[2] = sec;

	return GMS;
}

function runden_gms2(G, M, s, i)
{
//	Spezielle Rundungsroutine bei Grad, Grad und Dezimalminute
//	und Grad, Minute und Dezimalsekunde
//	------------------------------------------------------------------
//	Letzte Änderung:			09.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	G		--	Grad (Graddezimal oder Ganzzahlig) oder kodierte
//				Fliesskommazahl,
//				NaN: keine Umwandlung
//	M		--	Minuten (Minutendezimal oder Ganzzahlig),
//	s		--	Sekundendezimal
//	i		--	Kodierter Darstellungs- und Unwandelparameter mit 2 Stellen
//				Einerstelle:
//				i = y0: Graddezimal in G, m=NaN, s=NaN
//				i = y1: Grad, Minutendezimal in G und M, s=NaN
//				i = y2: Grad, Minute, Sekundedezimal
//				i = y3: Graddezimal in kodierter Form als Fliesskommazahl
//						(Beispiel: 23.12 = 23.12, also wie i=0)
//				i = y4: Grad, Min.dezimal in kodierter Form als Fliesskomma-
//						zahl (Beispiel: 23 01.2= 2301.2)
//				i = y5: Grad, Min. Sek.dezimal in kodierter Form als Fliess-
//						zahl (Beispiel: 23 12 13.123= 231213.123).
//				Anm.:   Für yi>2, s. a. codegrad_in_gms und gms_in_codegrad,
//				y=Zehnerstelle
//				Zehnerstelle:
//				i = 0x:	Altgrad in Altgrad
//				i = 1x:	Neugrad in Neugrad
//				i = 2x:	Altgrad in Neugrad
//				i = 3x:	Neugrad in Altgrad
//						x ist Einerstelle (s.o.)
//	optional (5. Argument):
//	genau	--	Dezimale auf den in der jeweiligen Option (y0,y1-y5)
//				gerundet werden soll
//				Fehlt genau oder ist genau < 0 || isNaN(genau) 
//				=> genau bei	y0,y3:	1.E-12,
//								y1,y4:	1.E-08, 1.E-09 (gon)
//								y2,y5:	1.E-04. 1.E-05 (gon)
//				Es wird kein Fehler ausgegeben.

// Ausgabe Feld GMS:
// GMS[0]	--  gerundeter Gradwert     bei yi=0 (Intervall: 0<=GMS[0]<360. oder 400.)
// GMS[1]	--  gerundeter Minutenwert  bei yi=1
// GMS[2]	--  gerundeter Sekundenwert bei yi=2
// GMS[0]	--	gerundeter kodierter Wert bei yi=3-5
//				Fehler:
//				-9000000:	Anzahl Argumente <4 oder >5.
//				-9000001:	i nicht im Bereich:	 0<=i<= 5,     10<=i<=15,
//												20<=i<=25 oder 30<=i<=35.
//				-9000002:	G	enthält Fehlercode (<=-9000000).
//				-9000003:	G	keine Zahl (NaN) bei i=0,3,10,13,20,23,30,33.
//				-9000004:	min keine Zahl (NaN) bei i=1,4,11,14,21,24,31,34.
//				-9000005:	sec keine Zahl (NaN) bei i=2,5,12,15,22,25,32,35.

	var GMS = new Array(3);
	var grad_gon, grmax, genau;
	var argnum;
	var an_i, gms_i, codegr, zw;

	GMS[0] = NaN;
	GMS[1] = NaN;
	GMS[2] = NaN;

//	Eingabevariablen testen
//	Anzahl Argumente
	argnum = arguments.length;
	if (argnum < 4 || argnum > 5){
		GMS[0] = -9000000;
		return GMS;
	}

//	gültige Umrechnungsmodi
	i		= parseInt(i);
	an_i	= Fix(i/10)*10;
	gms_i	= i-an_i;
	if (an_i < 0 || an_i > 30 || gms_i < 0 || gms_i > 5){
		GMS[0] = -9000001;
		return GMS;
	}

	codegr = false;
	if (gms_i > 2){
		gms_i = gms_i-3;
		codegr = true;

		GMS = codegrad_in_gms(G,gms_i);
		G	= GMS[0];
		M	= GMS[1];
		s	= GMS[2];
	}

//	Grad ist Zahl?
	G = parseFloat(G);
	if (isNaN(G)){
		GMS[0] = -9000003;
		return GMS;
	}

//	Eingabewert (Gradzahl) ist gültig, d.h. ist kein Fehlercode
//	z.B. durch vorherige Umrechnung ?
	if (G <= -9000000){
		GMS[0] = -9000002;
		return GMS;
	}

	M = parseFloat(M);
	s = parseFloat(s);


	if (an_i == 0 || an_i == 30){
//		Runden auf Altgrad
		grad_gon =  60.;
		grmax	 = 360.;
	}
	else{
//		Runden auf Neugrad (Gon)
		grad_gon = 100.;
		grmax	 = 400.;
	}


//	Stellengenauigkeit
	genau = -1;
	if (argnum == 5) genau = parseFloat(arguments[4]);

//	Defaultwerte für Genauigkeit, falls keine Eingabe erfolgte.
//	In gon bei c und cc eine Zehnerpotenz mehr, um dieselbe
//	Genauigkeit wie in Altgrad zu erreichen!!
	if (genau < 0 || isNaN(genau)){
		if (gms_i == 0) genau = 1.E-12;
		if (gms_i == 1){
			genau = 1.E-08
			if (an_i == 10 || an_i == 20) genau = genau*1.E-01;
		}
		if (gms_i == 2){
			genau = 1.E-04;
			if (an_i == 10 || an_i == 20) genau = genau*1.E-01;
		}
	}
	
	switch(gms_i){
//	Runden von Dezimalgrad
	case 0 :
		gr = lg_stellengenau(G,genau);
		mr = NaN;
		sr = NaN;
		break;

//	Runden von Grad, Dezimalminute
	case 1 :
//		Minute ist Zahl?
		if (isNaN(M)){
			GMS[0] = -9000004;
			return GMS;
		}

		mr = lg_stellengenau(M,genau);
		gr = Fix(G);
		if (Math.abs(mr) >= grad_gon){
			if (gr != 0){
				gr = gr + sgn(gr) * 1;
			}
			else{
				gr = sgn(mr) * 1;
			}
			mr = 0;
		}
		sr = NaN;
		break;

//	Runden von Grad, Minute, Dezimalsekunde
	case 2 :
//		Minute ist Zahl?
		if (isNaN(M)){
			GMS[0] = -9000004;
			return GMS;
		}
//		Sekunde ist Zahl?
		if (isNaN(s)){
			GMS[0] = -9000005;
			return GMS;
		}

		sr = lg_stellengenau(s,genau);
		gr = Fix(G);
		mr = Fix(M);
		if (Math.abs(sr) >= grad_gon){
			if (gr != 0){
				mr = Math.abs(mr) + 1;
				if (mr >= grad_gon){
					gr = gr + sgn(gr) * 1;
					mr = 0;
				}
			}
			else{
				if (mr != 0){
					mr = mr + sgn(mr) * 1
					if (Math.abs(mr) >= grad_gon){
						gr = sgn(mr) * 1;
						mr = 0;
					}
				}
				else{
					mr = sgn(sr) * 1;
				}
			}
			sr = 0;
		}
		break;

	}

//	Grad auf 360 oder 400 normieren
	if (Math.abs(gr) >= grmax) gr = gr - sgn(gr) * grmax;

	if (codegr){
		gr = gms_in_codegrad(gr,mr,sr,gms_i);
		mr = NaN;
		sr = NaN;
	}

	GMS[0] = gr;
	GMS[1] = mr;
	GMS[2] = sr;
	return GMS;

}

function read_gmstext(gmstext)
{
//	Einlesen einer Textzeile und durch beliebig viele Leerzeichen
//	separierte Zahlen in ein Datenfeld einlesen zur Weiterverwendung
//	als Grad, Minute, Sekunde. Gibt es keine Zahl (leere Zeichenkette)
//	oder mehr als 3 Zahlen, wird ein Fehler ausgegeben. 
//	------------------------------------------------------------------
//	Letzte Änderung:			08.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	gmstext	--	Zeichenkette (z.B. 10 12   12.1234)
//
//	Function-return:
//	Datenfeld GMS [0]:	Dezimalgrad oder ganzzahliges Grad
//				  [1]:	Dezimalminute oder ganzahlige Minute
//				  [2]:	Dezimalsekunde
//						
//	Fehler:	  GMS[0]: 
//					Fehler:
//					-9000002:	gmstext enthält Fehlercode (<=-9000000).
//					-9000007:	Zeichenkette leer oder mehr als 3 Werte

//	RegEx, beliebig viele Leerzeichen zum Trennen der Eingabewerte
	var re = new RegExp(" +");

	var GMS = new Array();
	var inw,i;
	
	inw = gmstext+"";
	GMS = inw.split(re);

//	alert("laenge: " + GMS.length);
	if (GMS.length == 0 || GMS.length > 3){
		GMS[0] = -9000007;
		return GMS;
	}

	if (GMS[0] <= -9000000){
		GMS[0] = -9000002;
		return GMS;
	}

//	Umwandlung des Dezimalanteils von Komma in Punkt
	i = GMS.length-1;
	GMS[i] = KommainPunkt(GMS[i]);

//	for(i=0;i<GMS.length;i++) alert("i" + i + ": " + GMS[i]);


	return GMS;

}

function write_gmstext(GMS)
{
//	Ausgabe eines Feldes in eine Textzeile. Die einzelnen Werte sind mit einem
//	Leerzeichen voneinander getrennt. Dient zur Weiterverwendung
//	als Grad, Minute, Sekunde. Ist das Feld leer (leere Zeichenkette)
//	oder gibt es mehr als 3 Zahlen, wird ein Fehler ausgegeben. 
//	------------------------------------------------------------------
//	Letzte Änderung:			08.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	GMS	--	Array für Grad, Minute, Sekunde (z.B.	GMS[0]=10,
//													GMS[1]=12, GMS[2]=12.1234)
//			Enthält ein Feld keine Zahl (isNaN), wird dieses nicht ausgegeben.
//
//	Function-return:
//	Zeichenkette:	Dezimalgrad oder 
//					Grad, Dezimalminute oder
//					Grad, Minute, Dezimalsekunde
//	
//						
//	Fehler:
//					Fehler:
//					-9000002:	GMS[0] enthält Fehlercode (<=-9000000).
//					-9000007:	GMS leer oder mehr als 3 Werte
//					-9000008:	kein GMS-Feld enthält eine Zahl.


	var text, i;

	text = "";

//	alert("laenge: " + GMS.length);
	if (GMS.length == 0 || GMS.length > 3)  return -9000007;
	if (GMS[0] <= -9000000)					return -9000002;
	
	for (i=0;i<GMS.length;i++){
		if (!isNaN(GMS[i])) text = text + GMS[i] + " ";
//		alert("i" + i + ": " + GMS[i]);
	}

//	Leerzeichen am Ende wieder entfernen
	text = text.substr(0,text.length-1);

//	Zeile leer
	if (text == "") 						return -9000008;
	
	return text ;
}



//	-------------------------------------------------------------------------------------
//	3.	Allgemeine Routinen
//		--	abs					Absolutbetrag
//		--	Fix oder fix		aus Fliesskommazahl ganzzahligen Wert machen
//		--	sgn oder Sgn		Vorzeichenfunktion in VB
//		--	sign				Vorzeichenfunktion in FORTRAN
//		--	lg_stellengenau		Runden/Abschneiden auf Nachkommastellen
//		--	kexp_von			größter 10-Exponent der Nachkommastellen
//		--	Dec_Places			wie kexp_von, aber als ganzzahlige Nachkommastelle
//		--	signif_decexp
//		--	signif_decplaces
//		--	aufrunden			Synonym für lg_stellengenau
//		--	KommainPunkt		Kommata in Punkte umwandeln 
//		--	browser_typ			Test, ob Netscape, Explorer oder anderer Browser
//		--	deco_fdate			internes Datumsformat in DD.MM.JJJJ
//		--	link_style			CSS-Style-File in HTML-Datei kopieren
//		--	email_verweis		<a mailto>-Tag über Javascriptfunktion erzeugen, um
//								Mailadressen nicht in html Spammern sichtbar zu machen
//		--	last_dateiaccess	Datum in DD.MM.JJJJ der letzten Änderung der aufgerufenen
//								HTML-Seite
//		--	tooltip				ToolTip-Box mit id="toolText sichtbar machen und Text
//								Box schreiben
//		--	tooltiphidden		ToolTip-Box mit id="toolText unsichtbar machen
//		--	tooltip_FISGP		wie Routine tooltip, aber Code wie in FIS/GP-Anwendung
//		--	isSetWinStat		Abfrage, ob in Statuszeile geschrieben werden kann
//		--	MSIEVersion			Major- und Minorversionsnummer des Internet Explorer
//								als 2-stellige Dezimalzahl ermitteln. 


function abs(a)
{
//	Betragsfunktion, kompatibel mit FORTRAN und
//	Basic-Namen
//	------------------------------------------------------------------
//	Letzte Änderung:			04.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	a	--	Fliesskommazahl
//	function-return
//		Betrag von <a>
//					Fehler:
//					-9000000:	Anzahl Argumente ungleich 1.
//					-9000003:	<a> keine Zahl (NaN).

	var argnum;

//	Eingabevariablen testen
//	Anzahl Argumente
	argnum = arguments.length;
	if (argnum != 1) return -9000000;

//	<a> keine Zahl
	if (isNaN(a)) return -9000003;
	
	a = parseFloat(a);
	return Math.abs(a);
}

function Fix(a)
{
//	Fix-Function in Javascript abbilden
//	------------------------------------------------------------------
//	Letzte Änderung:			04.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	a	--	Fliesskommazahl
//	function-return:
//		kleinster ganzzahliger Wert von a, wenn a>=0
//		größter ganzzahliger Wert von a, wenn a<0
//					Fehler:
//					-9000000:	Anzahl Argumente ungleich 1.
//					-9000003:	<a> keine Zahl (NaN).

	var argnum;

//	Eingabevariablen testen
//	Anzahl Argumente
	argnum = arguments.length;
	if (argnum != 1) return -9000000;

//	<a> keine Zahl
	if (isNaN(a)) return -9000003;
	
	a = parseFloat(a);

	if (a > 0){
		return Math.floor(a);
	}
	else{
		return Math.ceil(a);
	}

}

function fix(a)
{
//	wie Fix-function
//	------------------------------------------------------------------
//	Letzte Änderung:			04.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
	return Fix(a);
}

function sgn(a)
{
//	sgn-Function in Javascript abbilden
//	------------------------------------------------------------------
//	Letzte Änderung:			04.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	a	--	Fliesskommazahl
//	function-return:
//	 1, wenn a>0
//	 0, wenn a=0
//	-1, wenn a<0
//					Fehler:
//					-9000000:	Anzahl Argumente ungleich 1.
//					-9000003:	<a> keine Zahl (NaN).

	var argnum;

//	Eingabevariablen testen
//	Anzahl Argumente
	argnum = arguments.length;
	if (argnum != 1) return -9000000;

//	<a> keine Zahl
	if (isNaN(a)) return -9000003;
	
	a = parseFloat(a);

	if (a > 0)	return	1;
	if (a == 0)	return	0;
	if (a < 0)	return -1;
}

function Sgn(a)
{
//  wie sgn-Function
//	------------------------------------------------------------------
//	Letzte Änderung:			04.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------

	return sgn(a);
}

function sign(a,b)
{
//	Fortran sign-Function 
//	------------------------------------------------------------------
//	Letzte Änderung:			04.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	a	--	Fliesskommazahl
//	b	--	Fliesskommazahl
//	function-return:
//		sign = abs(a)*Vorzeichen(b), wobei
//					  Vorzeichen=-1,0 oder 1 ist.
//	Damit ist:	sign(1.,b) = sgn(b)
//					Fehler:
//					-9000000:	Anzahl Argumente ungleich 2.
//					-9000003:	<a> keine Zahl (NaN).
//					-9000003:	<b> keine Zahl (NaN).

	var argnum;

//	Eingabevariablen testen
//	Anzahl Argumente
	argnum = arguments.length;
	if (argnum != 2) return -9000000;

//	<a> keine Zahl
	if (isNaN(a)) return -9000003;
	
//	<b> keine Zahl
	if (isNaN(b)) return -9000003;

	a = parseFloat(a);
	b = parseFloat(b);

	return Math.abs(a)*sgn(b);

}

function lg_stellengenau(zahl,genauf)
{
//	Function zum Runden der Zahl <zahl> auf <genau> Stellen.
//	------------------------------------------------------------------
//	Letzte Änderung:			08.02.2005
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	zahl	--	abzuschneidene oder zu rundende Fliesskommazahl
//	genauf	--	Genauigkeit im Exponentialformat für normalisierte Fliesskommazahl
//				(Mantisse zwischen 0 und 1, z.B. 1.E-04 für 4 Nachkommstellen)
//				oder Anzahl von Nachkommastellen, die ausgegeben werden
//				sollen. Die letzte Stelle ist dann auf- oder abgerundet.
//	optional:
//	Parameter zum Abschneiden oder Runden
//	arguments[2]	--	true (=-1):		auf angegebene Stellenzahl abschneiden
//						false (!=-1), NaN oder keine Eingabe:
//										auf angegebene Stellenzahl Auf- oder Abrunden
//	Function-return
//	auf <genauf> Stellen gerundete Fliesskommazahl				
//					Fehler:
//					-9000000:	Anzahl Argumente nicht 2 oder 3
//					-9000001:	<genauf> nicht im gültigen Bereich
//								ganzzahlig:			0<=genauf<=14,
//								Exponentialformat:	0< genauf< 1.0.
//					-9000003:	<genauf> keine Zahl (NaN).

	var eps=1.E-14, epsdez=14;				// interne Rechengenauigkeit (14 Stellen)

	var nkstellen, ndez, zz, pkt, zexp, zest, genau;
	var argnum, abschneiden;
	var zzz;
	
//	Eingabevariablen testen
//	Anzahl Argumente
	argnum = arguments.length;
	if (argnum < 2 || argnum > 3)			return -9000000;

//	Abschneiden oder Runden?
	if (argnum == 2){
//		kein Argument eingegeben => runden
		abschneiden = false;
	}
	else{
		abschneiden = arguments[2];
	}
	if (isNaN(abschneiden)) abschneiden = false;
	
//	<genau> keine Zahl
	if (isNaN(genauf))						return -9000003;
	
//	<genau> nicht im Wertebereich
	if (genauf < 0 || genauf > epsdez)		return -9000001;
		
//	Typ von <genauf> ermitteln
	if (genauf == 0 || genauf >= 1){
//		<genauf> gibt Nachkommastellenanzahl an
		nkstellen	= parseInt(genauf);
	}

	else{
//		Ist <genauf> im Exponentialformat, Stellenanzahl aus Exponenten
//		ermitteln und Mantisse abschneiden
		if (genauf < eps)					return -9000001;
		
		nkstellen = -kexp_von(genauf);
	}

	genau	= Math.pow(10,-nkstellen);

//	Mathematische Rundung oder Abschneiden durchführen

	if (abschneiden){
//		Abschneiden
		zz = zahl;
		zexp = kexp_von(zz);
	}
	else{
//		Runden
		zz	 = Fix(Math.abs(zahl)/genau + 0.5)*genau;
		zexp = kexp_von(zz);
		zest = Math.pow(10,zexp);
		zz	 = sgn(zahl) * (zz + zest*eps*0.5);
		if (Math.abs(zz)<zest*eps) zz = 0.;
	}

//	Umwandeln in Stringformat und Abschneiden durch Formatierung entstandener
//	Reststellen
	zz = zz + "";

//	Wenn Exponent <zexp> der Zahl kleiner als maximale
//	Stellengenauigkeit (hier: 1.E-14) ist, werden restliche oder
//	nach Rundung  nicht mehr gültige Ziffern abgeschnitten.
//	Suchen nach Dezimalpunkt. Wenn keiner vorhanden ist, kann Zahl
//	ganzzahlig oder als Exponentialzahl (z.B. 1e14) ohne Mantisse dargestellt
//	werden. Das Abtrennen der restlichen nach Rundung nicht mehr gültigen
//	Ziffern entfällt dann.
	if (zexp <= epsdez-1){
		pkt = zz.search(/\./);
		if (pkt != -1){
//			Punkt gefunden
			est = zz.search(/e/i);
			if ( est == -1){
//			String <zz> im Fliesskommaformat
				ndez	= nkstellen;
				if (ndez > epsdez-(zexp+1)) ndez = epsdez-(zexp+1);
				if (ndez >=0){
					if (zz.length-1-pkt>ndez) zz = zz.substr(0,pkt+1+ndez);
				}
			}
			else{
//			String <zz> im E-Format
				ndez	= nkstellen+zexp;
				if (ndez > epsdez-1) ndez = epsdez;
				if (est-pkt+1>ndez) zz = zz.substr(0,pkt+1+ndez)+
										 zz.substr(est,zz.length-est);
			}
		}

	}
	else{
		pkt = zz.search(/\./);
		if (pkt != -1){
//			Punkt gefunden
			est = zz.search(/e/i);
			if ( est == -1){
//			String <zz> im Fliesskommaformat
				ndez	= epsdez-pkt;
				if (ndez < 0) ndez = 0;
				if (nkstellen < ndez) ndez = nkstellen;
				zz = zz.substr(0,pkt+1+ndez);
			}
			else{
//			String <zz> im E-Format
			ndez = est-pkt-2;
			if (ndez > epsdez) ndez = epsdez;
			zz = zz.substr(0,pkt+1+ndez)+
				 zz.substr(est,zz.length-est);
			}
		}
	}

	zzz = parseFloat(zz);

	return zzz;
	
}

function kexp_von(zahl)
{
//	Feststellen des 10er-Exponenten einer
//	zwischen 1.0-9.999... normalisierten Zahl
//	------------------------------------------------------------------
//	Letzte Änderung:			04.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	zahl		--	zu testende Zahl
//	Ausgabe:
//	function-return
//	kexp_von	--	Exponent der 10er-Potenz
//					Wertebereich 1.e-32 <= abs(zahl) <= 1.e+32
//	Beispiele:	0.005123 (=5.123E-03)    ergibt kexp_von= -3
//				5.123    (=5.123E+00)    ergibt kexp_von=  0
//				1003.456 (=1.003456E+03) ergibt kexp_von=  3
//	Sonderfall:	0.0      (definiert als 1.E-330)
//										 ergibt kexp_von=-330

	var eps=1.E-14;
	var emin=1.E-32, emax=1.E+32;

	var zz, test, kp, zzt;
	

	zz = Math.abs(zahl);


//	Sonderfall zz=0
	if (zz == 0){
		kp = -330;
	}    
	else{
		if (zz < emin){
//		zz < 1.e-32 => 1.e-99
			kp = -99;
		}
//		zz > 1.e+32 => 1.e+99
		else{
			if(zz > emax){
				kp = 99;
			}
			else{    
// 			Startbedingungen für andere Werte 
				test = emin;
				kp = -33;
				while (test <= zz+eps){
					test = test * 10.;
					kp = kp + 1;
				}
			}
		}
	}	

	return kp;
    
}

function Dec_Places(zahl)
{
//	Anzahl der Nachkommastellen bei |zahl| < 1.
//	------------------------------------------------------------------
//	Letzte Änderung:			04.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	zahl		--	zu testende Zahl
//	Ausgabe:
//	function-return
//	Dec_Places	--	Anzahl Nachkommastellen
//	Beispiele:		zahl=0.005 ->   Dec_Places=3
//					zahl=1.5   ->   Dec_places=0

	var kp;

	kp = kexp_von(zahl);
	if (kp > 0) kp = 0;

	return -kp;
}


function signif_decexp(zahl)
{
//	Funktion zur Bestimmung von signifikanten Nachkommastellen
//	als Zehnerexponent
//	------------------------------------------------------------------
//	Letzte Änderung:			04.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	zahl			--	zu testende Zahl
//	Ausgabe:
//	function-return
//	signif_decexp	--	Zehnerpotenz der letzten Stelle, die nicht
//						0 ist.
//	Beispiele:      zahl=1234.12        ->  signif_decexp=0.01
//					zahl=1234.          ->  signif_dexexp=1.
//					zahl=1234.120400    ->  signif_decexp=0.0001
//					zahl=-1234.000400   ->  signif_decexp=0.0001
//					zahl=-1234          ->  signif_dexexp=1.

	var test;
	var pkt, est, lz;
	var dezim;

	dezim = 1;
	if (isNaN(zahl)) return dezim;

	test = zahl + "";
	lz = test.length;
	if (lz == 0) return dezim;

//	Abschneiden restlicher "Nullen" bei Fliesskommadarstellung
	if (test.search(/e/i) == -1){
		while(test.substr(test.length-1,1) == "0"){
			test = test.substr(0,test.length-1);
		}
	}
	lz = test.length;
	if (lz == 0) return dezim;

//	Suchen nach Dezimalpunkt und Exponentialdarstellung.
//	Ist Exponentialdarstellung vorhanden, wird Wert des Exponenten genommen.
//	Ist kein Dezimalpunkt und keine Exponentialdarstellung vorhanden,
//	ist dezim=1.
	pkt = test.search(/\./);
	est = test.search(/e/i); 
	if(est == -1){
		if (pkt != -1){
			dezim = Math.pow(10,-(lz-1-pkt));
		}
	}
	else{
		dezim = Math.pow(10,parseInt(test.substr(est+1,lz-1-est)));
	}

// Gibt es keine Nachkommastellen, ergibt sich Eins als Returnwert

	return dezim;

}

function signif_decplaces(zahl)
{
//	Funktion zur Bestimmung von signifikanten Nachkommastellen
//	als Stellenwert
//	------------------------------------------------------------------
//	Letzte Änderung:			04.01.2004
//	Autor:						Lothar Gorling
//								e-mail:	  lothar.gorling@liag-hannover.de
//								Internet: http://www.liag-hannover.de
//	------------------------------------------------------------------
//	Eingabe:
//	zahl      -- zu testende Exponentzahl, z. B. 0.1, 0.001 usw.
//	Ausgabe:
//	function-return
//	signif_decplaces  --  1. signifikante Nachkommastelle
//						  (von rechts betrachtet), die <> 0 ist.
//	Beispiele:	zahl=0.001          ->  signif_decplaces=3
//				zahl=0.1            ->  signif_decplaces=1
//				zahl=0              ->  signif_decplaces=0
//				zahl=10.            ->  signif_decplaces=0

	var dezim;

	dezim = signif_decexp(zahl);

	return Dec_Places(dezim);

}

function aufrunden(wert,dez)
{
//	Auf-;Abrunden und Abschneiden von
//	Fliesskommazahlen
//	Beschreibung s. lg_stellengenau
//	Eingabe:
//	wert	--	zu rundene Fliesskommazahl
//	dez		--	Nachkommastelle oder Exponent
//				auf den gerundet werden soll
//				(z. B. 2 oder 1.E-02 usw.)
	var ww;

	ww = lg_stellengenau(wert,dez);
	return ww;

}

function KommainPunkt(strin)
{
//	Umwandlung von Komma in Punkt
//	Eingaben von dezimalpunkt oder Komma werden
//	so gleichbehandelt
//	Eingabe:
//	strin	-- Eingabestring
//	function-return
//		Umgewandelter Eingabestring (alle
//		Kommata in Punkt umgesetzt)
//		leer:	Eingabestring leer
//		false:	Eingabevariable nicht definiert
	var strmitpunkt = "";

	for(i=0;i<strin.length;i++){
		if (strin.substr(i,1) == ","){
		strmitpunkt = strmitpunkt + ".";
		}
		else{
			strmitpunkt = strmitpunkt + strin.substr(i,1);
		}
	}

	return strmitpunkt;
}


function browser_typ()
{
//	Javasript zum Feststellen, welcher Browser  Netscape oder Explorer
//	Rueckgabewerte: netscape, explorer, anderer
//	Autor:                  Lothar Gorling
//	erstellt:               15.06.2000    
//	letzte Aenderung: 		10.02.2004
//	Eingabe:
//	keine
//	Ausgabe:
//	function-return:
//	browser_typ	--	"netscape"	=> Netscape-Browser
//					"explorer"	=> Internet-Explorer

	var   brow_name = navigator.appName

	if (brow_name.search(/scape/) != -1){
    	return "netscape";
	}
	else{  
		if (brow_name.search(/plorer/) != -1){
			return "explorer";

		}
		else{
			return "anderer";

		}
	}
}

function deco_fdate(wert)
{
//	Funktion zum Dekodieren des Datums von Netscape und Exlplorer
//	z. B. beim Feld document.lastModified auf ein einheitliches Format
//	Netscape-Format:  	friday, june 2, 2000 13:50:20
//	Explorer-Format:    02/06/00 (entspricht amerik. Notation mm/dd/yy
//	Der Datumsanteil wird in dd.mm.yyyy umkodiert und als Funktionswert uebergeben
//	Bei Microsoft wird bei Jahreswerten zwischen 70-99  19 vorangestellt, also
//	06/02/98 => 02.06.1998 und 06/02/00 => 02/06/2000
//	Fuehrende Blanks und Gross/Kleinschreibung oder Blanks zwischen den
//	Datumsanteilen beim Netscape-Format werden ignoriert
//	Autor:               Lothar Gorling
//	Erstellungsdatum:    18.06.2000
//	Letzte Modifikation: 10.02.2004
//	Eingabe:
//	wert		--	Netscape oder Explorer-Timeformat (s.o.)
//	Ausgabe:
//	Function-return:
//	deco_fdate	--	standardisiertes Format in DD.MM.JJJJ (s.o.)

	var day_arr, mon_arr, year_arr;
	var day, monat, jahr;
	var wb = "";
	var mydat = "";
	var mzahl;
	var delim = ".";
	var datums_test, netscape_form, jahr_test;

	jmon = new Array ("january","february","march","april","may","june",
                             "july","august","september","october","november","december"); 

	wb = wert.toLowerCase();        //	auf Kleinbuchstaben normalisieren
	wb = wb.match(/\S.+/);       	//  Fuehrende Blanks ignorieren

	datums_test = /\w,\s+\w/;      	//  Netscape oder anderes Format, i.d.R. Explorer-Format
	netscape_form = datums_test.test(wb);

	if (netscape_form){ 
//	Netscape-Format
  
		day_arr		= wb[0].match(/\w\s*\d+,\s/);
		mon_arr		= wb[0].match(/,\s*\w*\s/);
		year_arr	= wb[0].match(/,\s*\d+/);
		monat		= mon_arr[0].match(/\w+/);
		day			= day_arr[0].match(/\d+/);
		jahr		= year_arr[0].match(/\d+/); 

		if (jahr == 1970){ 
      		mydat =  "undefined, Netscape neu aufrufen"
      		return mydat;

      	}
    	for (i=0; i<12; i++){		// Monatszahl bestimmen
			if (monat == jmon[i]){
				mzahl = i+1;
				break;
			} 
		}
		day		= (eval(day) <10) ? "0" + day  :  day ;
		mzahl   = (mzahl  <10) ? "0" + mzahl  :  mzahl ;
	}
	else{
//	Explorer-Format

		day   = wb[0].substr(3,2);
		mzahl = wb[0].substr(0,2);
		jahr_test = /\/\d\d\d\d/;
		if (jahr_test.test(wb)){ 
			jahr    = wb[0].substr(6,4);
    	}
    	else{
    		jahr    = wb[0].substr(6,2);
			jahr    = (eval(jahr) > 69) ? "19" + jahr : "20" + jahr;
		}
	}

	mydat = day  +  delim + mzahl +  delim +  jahr;
	return mydat;

}

function link_style(style_datei,media)
{
//	Einsetzen von CSS-Pfad- und Filenamen ins Dokument
//	Autor:                  Lothar Gorling
//	erstellt:               15.06.2000    
//	letzte Aenderung:       10.02.2004
//	Eingabe:
//	style	--	Pfad- und Filename für Styledatei
//	media	--	Mediatyp, wie in CSS beschrieben
//	Ausgabe:
//	keine

	document.write("<LINK href=\"" + style_datei + "\" media=\"" + media + "\"  rel=\"stylesheet\" type=\"text/css\">");
}

function email_verweis(addressleft,reftext)
{
//	e-mail Verweis aus String aufbauen, um Spamming zu vermeiden bzw.
//	zu reduzieren. Das @-Zeichen (64D) wird als
//	ASCII-Code-Nummer übergeben.
//	Autor:                  Lothar Gorling
//	erstellt:               15.06.2000   
//	letzte Aenderung:       19.01.2009
//	Eingabe:
//	adressleft	--	linker Teil der email-Adresse (bis zum @)
//	reftext		--	Text für <a>Tag, i.d.R. voller Name
//	optional:
//	org			--	3. Parameter
//					Organisationseinheit der Mailadresse
//					fehlt <org>, so ist <org>="liag-hannover"
//	lcode		--	4. Parameter
//					Ländercode der Mailadresse
//					fehlt <lcode>, so ist <lcode>="de"
//	Ausgabe:
//	Function-return
//	email_verweis	--	false=Fehler aufgetreten,
//						<a>-Tag wurde nicht geschrieben
//						true=kein Fehler. <a>-Tag wurde geschrieben
//	Historie:
//	19.01.09, LG:	GGA in LIAG

	var argnum, org, lcode;
	
//	Defaults
	org		= "liag-hannover";
	lcode	= "de";

	argnum = arguments.length;
	if (argnum < 2 || argnum > 4) return false;

	if (argnum == 3) org	= arguments[2];
	if (argnum == 4) lcode	= arguments[3];
	
	document.write("<a href=\"" + "mailto:"+ addressleft +
  		String.fromCharCode(64)+org+ "." + lcode + "\">"+
  		reftext+"</a>");
	
	return true;

}

function last_dateiaccess(lastmod)
{
//	Feststellen, wann letzter Dateizugriff stattfand
//	Autor:                  Lothar Gorling
//	erstellt:               15.06.2000
//	letzte Aenderung:       10.02.2004
//	Eingabe:
//	lastmod		--	Datum aus Text. Wird verwendet, wenn mit Netscape
//					gearbeitet wird, weil dieser Browser den Befehl
//					document.lastModified nicht versteht.
//	Function-Return:
//	last_dateiaccess	--	Datum im Format DD.MM.JJJJ	

	var lastmodz;

	if (browser_typ() == "netscape"){
//  fuer Netscape-Browser
//  Variable fuer letzten Bearbeitungsstand in Netscape
//  wird hier gesetzt und nicht mit document.lastModified abgefragt
//  Inkompatibilitaeten mit verschiedenen Versionen des
//  Explorer und Netscape

    	lastmodz = lastmod;

	}
	else{
//  fuer explorer oder andere Browser

		lastmodz = deco_fdate(document.lastModified);

	}

	return lastmodz;
}

function get_hmsPCtime()
{
//	Lokale PC-Zeit mit Stunde, Minute, Sekunde bestimmen 
//	und führende 0 ergänzen
//	Autor:                  Lothar Gorling
//	erstellt:               07.03.2005
//	letzte Aenderung:       07.03.2005
//	Function-Return:
//	get_hmsPCtime		--	Zeit im Format hhmmss als String
//							mit führenden Nullen, wenn Stunden, Minuten oder
//							Sekunden kleiner 10 sind.
	var d = new Date();
	var h,m,s;

	h = d.getHours() + "";
	if (h.length < 2) h = "0"+h;
	m = d.getMinutes() + "";
	if (m.length < 2) m = "0"+m;
	s = d.getSeconds() + "";
	if (s.length < 2) s = "0"+s;
	
	return h+m+s;

}

function tooltipHidden()
{
//	Funktion zum Ausblenden der Tooltips.
//	Benutzt Javascript-DOM-Objekt mit der ID="toolText"
//	Autor:                  Klaus Kühne
//	Erstellt:               15.06.2000
//	Letzte Änderung:		19.02.2009, LG
//
//	Function-Return:
//	kein Wert


	document.getElementById("toolText").style.visibility = "hidden";
}    
 
function tooltip(tooltipText, breite, e)
{
//	Funktion zum Anzeigen der Tooltips.
//	Benutzt Javascript-DOM-Objekt mit der ID="toolText"
//	Autor:                  Klaus Kühne 
//	Erstellt:               15.06.2000
//	Letzte Änderung:		19.02.2009, LG
//	Eingabe:
//	tooltipText	--	Text zum Beschreiben in Box
//	breite		--	breite in Pixel der Box
//	e			--	event-Objekt. Wird benötigt,
//					zur Rückgabe der Mausposition
//
//	Function-Return:
//	kein Wert

	var korrekturX = 20;
	var korrekturY = 20;
	var maxCol, maxRow;
	var startCol, startRow;

	document.getElementById("toolText").style.visibility = "hidden";
      

	maxRow = document.body.offsetHeight;
	maxCol = document.body.offsetWidth;

	if (document.all) {
		startCol = event.clientX + document.body.scrollLeft + 10 + korrekturX;
		startRow = event.clientY + document.body.scrollTop - 5 + korrekturY;
	} else {
		startCol = e.clientX + pageXOffset + korrekturX;// + 20;
		startRow = e.clientY + pageYOffset + korrekturY;
	}
	   
//	schreibt den Text in den Tooltip
	document.getElementById("toolText").innerHTML = tooltipText;
	if (startCol+breite > maxCol) startCol = maxCol-breite;
	if (startRow+document.getElementById("toolText").offsetHeight > maxRow)
			startRow = maxRow-document.getElementById("toolText").offsetHeight;

	if (document.all) {
		document.getElementById("toolText").style.left = startCol;
		document.getElementById("toolText").style.top = startRow;
		document.getElementById("toolText").style.width = breite;
	}
	else {
		document.getElementById("toolText").style.left = startCol + "px";
		document.getElementById("toolText").style.top = startRow + "px";
		document.getElementById("toolText").style.width = breite + "px";
	}
	   
	document.getElementById("toolText").style.visibility = "visible";

}

function tooltip_FISGP(tooltipText, breite, e)
{
//	Funktion zum Anzeigen der Tooltips.
//	Benutzt Javascript-DOM-Objekt mit der ID="toolText"
//	Autor:                  Klaus Kühne
//	Erstellt:               15.06.2000    
//	Letzte Änderung:		19.02.2009, LG  (nur Kosmetik)
//	Eingabe:
//	tooltipText	--	Text zum Beschreiben in Box
//	breite		--	breite in Pixel der Box
//	e			--	event-Objekt. Wird benötigt,
//					zur Rückgabe der Mausposition
//
//	Function-Return:
//	kein Wert

	document.getElementById("toolText").style.visibility = "visible";

	var korrekturX = 20;
	var korrekturY = 20;      

	if (document.all) {
		document.getElementById("toolText").style.left = event.clientX + document.body.scrollLeft + 10 + korrekturX;
		document.getElementById("toolText").style.top = event.clientY + document.body.scrollTop - 5 + korrekturY;
		document.getElementById("toolText").style.width = breite;
	}
	else {
		document.getElementById("toolText").style.left = e.clientX  + pageXOffset + korrekturX;// + 20;
		document.getElementById("toolText").style.top = e.clientY + pageYOffset + korrekturY;
		document.getElementById("toolText").style.width = breite;
	}
//	schreibt den Text in den Tooltip
	document.getElementById("toolText").innerHTML = tooltipText;
}
    
function isSetWinStat()
{

// 	Ermitteln des Status der Statuszeile und der Versionsnummer
//	(major- und Minor number) für Internet Explorer
//	Autor:                  Lothar Gorling
//	Erstellt:               19.02.2009    
//	Letzte Änderung:		19.02.2009
//
//	Function-Return:
//	Array retArr(3) mit 3 String-Werten:
//	retArr[0]	--	Status der Statuszeile
//					"0": aus
//					"1": an, d.h. kann beschrieben werden
//	retArr[1]	--	String-Wert von window.defaultStatus
//	retArr[2]	--	2-stellige Zahl als String der Versionsnummer des
//					Internet Explorers (Major Nummer*10+Minor Nummer)
//					oder "-1"
//	Anmerkung:
//	Beim FireFox ist die Abfrage je nach Einstellung korrekt,
//	beim IE6 und kleiner ist die Statuszeile immer an, da es keine
//	Einstellung dazu gibt.
//	Beim IE7 kann man sie zwar anstellen, der Wert wird auch zwischen-
//	zeitlich angezeigt, dann aber immer mit dem Defaultwert überschrieben.

	var testWert="LIAG-08-12-2008xxx";
	var lfdstatus, test, versnum;
	var retArr = new Array(3);
  
	lfdstatus = window.status;
	window.status = testWert;
      
	retArr[0] = "0";
	if (window.status == testWert) {
		retArr[0] = "-1";
		window.status = ""+lfdstatus;
	}
	retArr[1] = ""+window.defaultStatus;


//	Major Versionsnummer für Internet Explorer herausfinden
//	Für IE7 wird Schreiben in Statuszeile immer auf "0" (=false) gesetzt! 
/*
	versnum = -1;
	test = navigator.appVersion.match("MSIE[ |\t]+[0-9]");
	if (test){
		if (test[0].length > 0) versnum = test[0].substr(test[0].length-1,1);
		if (versnum > 0){
			if (versnum > 6) retArr[0] = "0";
		}
	}
*/
	versnum = MSIEVersion();
	if (versnum > 0) versnum = versnum/10;
	if (versnum > 6) retArr[0] = "0";
	
	retArr[2] = ""+versnum;

	return retArr;  

}

function MSIEVersion()
{
//	Major- und Minorversionsnummer für Internet Explorer herausfinden
//	und als Dezimalzahl übergeben.
//	Autor:                  Lothar Gorling 
//	Erstellt:               19.02.2009
//	Letzte Änderung:		19.02.2009
//
//	Function-Return:
//	2-stellige ganzahlige Versionsnummer, falls Aufruf mit Internet Explorer
//	als Browser erfolt oder -1, wenn fremder Browser.
//	z.B.:	MSIEVersion = 70:	Aufruf erfolgte mit Browser IE 7.0,
//			MSIEVersion = 61:	IE 6.1 usw.
//			MSIEVersion = -1:	kein Internet Explorer 
//	

	var test, versnum;

	versnum = -1;
//	regulärer Ausdruck. Sucht z. B. nach String mit MSIE 7.0
	test = navigator.appVersion.match("MSIE[ |\t]+[0-9]\.[0-9]");
	if (test){
		if (test[0].length > 0){
			versnum = test[0].substr(test[0].length-3,1)*10+
					  test[0].substr(test[0].length-1,1)*1;
		}
	}

	return versnum;  

}