/* ========================================================================================================
	PANEL2 - Ein-/Ausklapp-Funktion zum Panel
	Copyright (c) Wolfram Biedermann, Regen - Jede unerlaubte Verwendung untersagt
   ========================================================================================================
*/

// status_eingeblendet: Flag ja/nein (also Startsituation Panel ein- oder ausgeblendet)
// Bei nicht senkrecht wird die Bedeutung der Begriffe vertauscht, die Variablennamen bleiben ! (also Y->X, Breite->Hoehe)

function syscl_panel2 ( panel_id, no_panel_id, senkrecht, status_eingeblendet, body_aendern, cookiename_nopanel )
{
	var thisObject = this;
	var panel;
	var no_panel;
	var is_init = false;

	var in_move = false;
	var in_step1_move = false;

	var breite_panel = 40;
	var hoehe_panel;

	var sw_panel = 25;
	var delay_panel = 15;
	var sw_body = 5;
	var delay_body = 10;

	var move_rest_panel = 0;
	var move_takt_panel = false;
	var move_rest_body = 0;
	var move_takt_body = false;

	var y_panel = 0;
	var margin_body = 0;

	///////////////////////////////////////////////////////
	// Parameter zur Animation
	//
	this.set_tech_param = function set_tech_param ( swPanel, delayPanel, swBody, delayBody )
	{
		sw_panel = swPanel;
		delay_panel = delayPanel;
		sw_body = swBody;
		delay_body = delayBody;
	}

	///////////////////////////////////////////////////////
	// init
	// Das Panel kommt von PHP immer an (0,0) positioniert und nach Status ein- oder ausgeblendet.
	// So kann es dann auch funktionieren, wenn js abgeschaltet ist und es kommt beim Seitenaufbau ohne Verzoegerung auf den Bildschirm.
	// Eine Positionsermittlung vor onload ist nicht moeglich, weil viele Browser dann die freie Dimension falsch rechnen.
	// Ermittle die Dimensionen daher erst beim ersten toggle. (in status_toggle() den Aufruf vor onload ausschliessen !)
	//
	this.initialisieren = function initialisieren ()
	{
		if( is_init )
	return;

		panel = document.getElementById( panel_id );
		no_panel = document.getElementById( no_panel_id );

// Wenn ausgeblendet, erst einblenden (Panel sitzt dabei links bzw. oberhalb des Fensters und ist nach wie vor nicht sichtbar)
// erst bei display block kann man rechnen
		if( !status_eingeblendet ){
			panel.style.display = "block";
		}
// Dimensionen ermitteln
// ALLE BEZEICHNUNGEN BEZOGEN AUF SENKRECHTES PANEL, BEI WAAGRECHT TAUSCH DER BEDEUTUNGEN !!
		if( senkrecht ) {
			breite_panel = panel.offsetWidth;
			hoehe_panel = panel.offsetHeight;
		}
		else {
			breite_panel = panel.offsetHeight;
			hoehe_panel = panel.offsetWidth;
		}
// Wo hat sich das Panel zu befinden? (bei ausgeblendet um die Hoehe nach oben versetzt)
// Die hier ermittelte margin fuer den Body muss bereits in PHP gesetzt worden sein sein)
		if( status_eingeblendet ) {
			y_panel = 0;
			margin_body = breite_panel;
		}
		else {
			y_panel = -hoehe_panel;
			margin_body = 0;
		}

// Position setzen (bei eingeblendet aendert sich nix, bei ausgeblendet auf die Startpos. zum Hereinschieben)
		if( senkrecht ){
			panel.style.top = y_panel + "px";
			panel.style.left = 0;
		}
		else {
			panel.style.left = y_panel + "px";
			panel.style.top = 0;
		}
		is_init = true;
	}

	///////////////////////////////////////////////////////
	// Panel ein- und ausblenden (Eventhandler fuer Klick auf Schalter)
	//
	this.status_toggle = function status_toggle ()
	{
		var ablauf, inEinemJahr;

// Eine Positionsermittlung vor onload ist nicht moeglich, weil viele Browser dann die freie Dimension falsch rechnen.
		if( !system_floatResize.isOnloadInit() )
	return;
		if( system_floatResize.isInEvent() )	// Resize hat Prioritaet, auf move einfach verzichten
	return;
		if( in_move ) // verhindere Unterbrechung durch erneuten move-Aufruf
	return;
		in_move = true;
		thisObject.initialisieren();		// nur beim ersten Aufruf von Bedeutung

		if( status_eingeblendet )
		{
// Fuer is_step1 das Flag body_aendern hernehmen. Wenn nicht, gibt es nur einen Schritt, dann soll es nicht gesetzt werden
			thisObject.panel_move_ausfuehren( true, body_aendern, -sw_panel );
			if( body_aendern )
				thisObject.body_move_ausfuehren( true, false, -sw_body );
			thisObject.noPanel_toggle( true );
		}
		else 
		{
			thisObject.noPanel_toggle( false );
			if( body_aendern )
				thisObject.body_move_ausfuehren( true, true, sw_body );
// is_step1 ist hier auf jeden Fall false (entweder 2. Schritt oder es gibt nur diesen einen)
			thisObject.panel_move_ausfuehren( true, false, sw_panel );
		}

		ablauf = new Date();
		inEinemJahr = ablauf.getTime() + (365 * 24 * 60 * 60 * 1000);
		ablauf.setTime( inEinemJahr );

		status_eingeblendet = !status_eingeblendet;
// Das Cookie muss bei "ausgeblendet" "true" setzen, sonst false (siehe session.php)
		document.cookie = cookiename_nopanel + '=' + ( status_eingeblendet ? 'false' : 'true' ) + ';expires=' + ablauf.toGMTString();
	}

	///////////////////////////////////////////////////////
	// noPanel_toggle
	// Blendet den Ersatztext (div no_panel_id) ein bzw. aus.
	// Beim Ausblenden des Panels muss gewartet werden, bis der Verschiebevorgang beendet ist (in_move)
	// Frage immer auf in_move ab, denn beim Einblenden wird noPanel_toggle ZUERST gerufen, da ist in_move noch nicht gesetzt
	// 
	this.noPanel_toggle = function noPanel_toggle ( noPanel_einschalten )
	{
		if( in_move )
			window.setTimeout( function () { thisObject.noPanel_toggle( noPanel_einschalten ); }, 20 );
		else {
			if( noPanel_einschalten )
				no_panel.style.display = "block";
			else
				no_panel.style.display = "none";
		}
	}
	
	///////////////////////////////////////////////////////
	// Panel verschieben
	// einblenden: Flag
	// is_step1: Zuerst aufgerufene Funktion ja/nein ? (Bei Ein- und ausblenden umgekehrte Reihenfolge)
	// 
	this.panel_move_ausfuehren = function panel_move_ausfuehren ( init, is_step1, schrittweite )
	{
		var verwendete_sw = schrittweite;
		var rest;

// Anfang der Prozedur. Sperre gegen Mehrfachaufrufe
		if( init ) {
			move_rest_panel = hoehe_panel * system_mathErgSgn( schrittweite );
			move_takt_panel = true;
			if( is_step1 )
				in_step1_move = true;
		}
		if( move_rest_panel == 0 ) {
// Wenn nur erster Schritt, gebe den 2. frei, ansonsten alles
			if( is_step1 )
				in_step1_move = false;
			else
				in_move = false;
	return;
		}

// Wenn erster Schritt ist, ansonsten nur, wenn der erste Schritt bereits erledigt ist (!in_step1_move)
		if( is_step1 || !in_step1_move ) 
		{
// Wenn der naechste Takt freigegeben ist oder beim ersten Mal (init, s.o.)
			if( move_takt_panel )
			{	
				move_takt_panel = false;
				setTimeout( function() { move_takt_panel = true; }, delay_panel );

				rest = move_rest_panel - verwendete_sw;
	
				if( ( verwendete_sw > 0 && rest < 0 ) || ( verwendete_sw < 0 && rest > 0 ) ) {
					verwendete_sw = move_rest_panel;
					rest = 0;
				}

				move_rest_panel = rest;
				y_panel += verwendete_sw;
				if( senkrecht )
					panel.style.top = y_panel + "px";
				else
					panel.style.left = y_panel + "px";
			}
		}
		window.setTimeout( function () {
						thisObject.panel_move_ausfuehren( false, is_step1, schrittweite );
					},
					1 );
	}

	///////////////////////////////////////////////////////
	// Body veraendern
	//
	this.body_move_ausfuehren = function body_move_ausfuehren ( init, is_step1, schrittweite )
	{
		var verwendete_sw = schrittweite;
		var rest;

// Anfang der Prozedur. Sperre gegen Mehrfachaufrufe
		if( init ) {
			move_rest_body = breite_panel * system_mathErgSgn( schrittweite );
			move_takt_body = true;
			if( is_step1 )
				in_step1_move = true;
		}
		if( move_rest_body == 0 ) {
// Wenn nur erster Schritt, gebe den 2. frei, ansonsten alles
			if( is_step1 )
				in_step1_move = false;
			else
				in_move = false;
// Da der Body veraendert wurde, resize ausloesen
			system_floatResize.eventhandler();
	return;
		}

// Wenn erster Schritt ist, ansonsten nur, wenn der erste Schritt bereits erledigt ist (!in_step1_move)
		if( is_step1 || !in_step1_move ) 
		{
// Wenn der naechste Takt freigegeben ist oder beim ersten Mal (init, s.o.)
			if( move_takt_body )
			{	
				move_takt_body = false;
				setTimeout( function() { move_takt_body = true; }, delay_panel );

				rest = move_rest_body - verwendete_sw;
	
				if( ( verwendete_sw > 0 && rest < 0 ) || ( verwendete_sw < 0 && rest > 0 ) ) {
					verwendete_sw = move_rest_body;
					rest = 0;
				}

				move_rest_body = rest;
				margin_body += verwendete_sw;

				if( senkrecht )
					document.body.style.marginLeft = margin_body + "px";
				else
					document.body.style.marginTop = margin_body + "px";
// 				system_floatResize.eventhandler();
			}
		}
		window.setTimeout( function () {
						thisObject.body_move_ausfuehren( false, is_step1, schrittweite );
					},
					1 );
	}

//========================================================================================================
//	Resize-Funktionen
//========================================================================================================

// !!! Die Methoden resizeInit(), onloadInit, resize(), isLocallyProtected() sind Systemfunktionen
// Sie haben hier kaum eine Bedeutung. Initialisiert wird das Panel beim ersten Toggle

	///////////////////////////////////////////////////////
	//  Systemfunktion resizeInit
	//  Rueckgabe:keine
	//
	this.resizeInit = function resizeInit () {
	return;
	}

	///////////////////////////////////////////////////////
	//  Systemfunktion onloadInit
	//  Rueckgabe:keine
	//
	this.onloadInit = function onloadInit () {
	return;
	}

	///////////////////////////////////////////////////////
	//	Systemfunktion isLocallyProtected
	//  anhand dieser Methode erkennt system_floatResize, ob ein lokaler Event einen Schutz gegen gleichzeitiges Aufrufen
	//  von resize() benoetigt. Falls ja, wartet system_floatResize, bis der lokale Schutz nicht mehr existiert, also bis die
	//  Methode isLocallyProtected() false zurueckgibt.
	//
	this.isLocallyProtected = function isLocallyProtected ()
	{
	return false;
	return in_move;
	}

	///////////////////////////////////////////////////////
	// Systemfunktion resize
	// muss folgende Rueckgaben machen: true fuer VERAENDERT, false fuer UNVERAENDERT
	//
	this.resize = function resize ()
	{
	return false;
	}
}