/* ========================================================================================================
	DYNAMISCHER WRAPPPER
	dynwrap.js
	Copyright (c) Wolfram Biedermann, Regen - Jede unerlaubte Verwendung untersagt
   ========================================================================================================
*/

// bot_bound: Flag, ob ans untere Ende des Browserfensters gebunden (d.h. wenn H Seite < H Fenster, wird Seite nach unten verlaengert.
// abst_bot hat nur bei bot_bound==true einen Sinn. 

function dynwrap ( wrapper_id )
{
	var thisObject = this;
	var wrapper;

	var dependend_divs = [];
	var bound_to_divs = [];
	var h_wrap_alt;
	var min_height = 0;	

	var min_width = 0;
	var max_width = 0;	

	var bot_bound = false;
	var abst_bot = 0;

	var nullzahl_alt = -1;

	///////////////////////////////////////////////////////
	// Mindesthoehe setzen
	// Wenn 0 -> keine Mindesthoehe
	//
	this.set_min_height_pix = function set_min_height_pix ( h )
	{
		min_height = h;
	}

	///////////////////////////////////////////////////////
	// Mindesthoehe setzen
	// Wenn 0 -> keine Mindesthoehe
	//
	this.set_bot_bound_pix = function set_bot_bound_pix ( h )
	{
		bot_bound = true;
		abst_bot = h;
	}

	///////////////////////////////////////////////////////
	// divs, von denen der dynwarpper abhaengig ist, eintragen
	// von diesen divs wird die unterkante ermittelt, zzgl. eines evtl. Additionswertes (wirkt wie eine Margin)
	// Die Unterkante des dynwrappers ist unterste UK aller bound-to-divs zzgl. addwert (auch negativ)
	//
	this.register_bound_to_div_pix = function register_bound_to_div_pix ( div_id, addwert )
	{
		var i = bound_to_divs.length;

		bound_to_divs[i] = {};
		bound_to_divs[i]["id"] = div_id;
		bound_to_divs[i]["addwert"] = addwert;
	}

	///////////////////////////////////////////////////////
	// abhaenige divs eintragen
	//
	this.register_dependend_div_pix = function register_dependend_div_pix ( div_id, addwert )
	{
		var i = dependend_divs.length;

		dependend_divs[i] = {};
		dependend_divs[i]["id"] = div_id;
		dependend_divs[i]["addwert"] = addwert;
	}

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

	///////////////////////////////////////////////////////
	// Absolutes Unten ermitteln
	//
	this.getAbsoluteBottom = function getAbsoluteBottom ( id )
	{
		var abs_y = 0;
		var elem = document.getElementById( id );
		var h_div;

		if( !elem )
	return -1;

		h_div = elem.offsetHeight;
		while( elem ){
			abs_y = abs_y + elem.offsetTop;
			elem = elem.offsetParent;
		} //while( elem != document.documentElement );
	return abs_y + h_div;
	}

	///////////////////////////////////////////////////////
	// onloadInit
	// h_wrap_alt nochmal auf Null zuruecksetzen und somit beim folgenden resize Neuberechnung erzwingen
	//
	this.onloadInit = function onloadInit () {
		h_wrap_alt = 0;
	}

// !!! Die Methoden resizeInit(), resize() und isLocallyProtected() werden von system_floatResize benoetigt

	///////////////////////////////////////////////////////
	//  Systemfunktion resizeInit
	//  Die .resizeInit()-Methode wird beim Eintragen des resize-Handlers gerufen.
	//  Rueckgabe:keine
	//
	this.resizeInit = function resizeInit ()
	{
		wrapper = document.getElementById( wrapper_id );
		h_wrap_alt = 0;
		nullzahl_alt = -1;
	}

	///////////////////////////////////////////////////////
	//	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;
	}

	///////////////////////////////////////////////////////
	// Systemfunktion resize
	// Bild Ausgeben, wenn veraendert
	// muss folgende Rueckgaben machen: true fuer VERAENDERT, false fuer UNVERAENDERT
	// Arbeitet mit ABSOLUTEN Koordinaten, daher isr es moeglich, "wilde" Verknuepfungen bound-to und dependent zu machen, auch wenn diese
	// ausserhalb des dyn-wrappers stehen. Massgeblich ist immer absolute die Unterkante eines Elements bzw. des Wrappers.
	//
	this.resize = function resize ()
	{
		var anz_dep_divs = dependend_divs.length;
		var anz_boundto_divs = bound_to_divs.length;

		var rueck = false;
		var i;
		var elem;
		var uk = 0, tiefste_uk = 0;
		var h_div, addiere;
		var window_h;
		var h_wrap = wrapper.offsetHeight; // init, falls an kein Element gebunden
		var uk_wrap = 0;
		var nullzahl_neu = 0;
		var preOnloadTrack_darst = false;

// 0.) fuer PreOnloadTracking (s.u.) Zahl der noch nicht vorhandenen divs ermitteln. Wenn sie sich aendert (kann nur weniger werden),
// fuehrt auch das zum Neuaufbau. Nach onload kann sich die nullzahl nichts mehr aendern, dann diese Bedingung nicht mehr pruefen

		if( !system_floatResize.isOnloadInit() ) {
			for ( i = 0; i < anz_boundto_divs; i++ ) {
				if( !document.getElementById( bound_to_divs[i]["id"] ) )
					nullzahl_neu++;
			}
			if( nullzahl_neu != nullzahl_alt ) {
				preOnloadTrack_darst = true;
				nullzahl_alt = nullzahl_neu;
			}
		}
		
// 1.) neue Hoehe des Dyn-wrappers ermitteln
		for ( i = 0; i < anz_boundto_divs; i++ )
		{
			if( ( uk = thisObject.getAbsoluteBottom( bound_to_divs[i]["id"] )) >= 0 ) {
				uk += bound_to_divs[i]["addwert"];
// Merke die tiefste UK (die mit dem hoechsten Zahlenwert), immer die erste
				if( i == 0 || uk > tiefste_uk )
					tiefste_uk = uk;
			}
		}

// Unterkante evtl. an window-bottom binden
		if( bot_bound )	{
			window_h = window.innerHeight;
			if( typeof window_h == 'undefined' )
				window_h = document.documentElement.clientHeight;
			if( tiefste_uk + abst_bot < window_h )
				tiefste_uk = window_h - abst_bot;
		}

// Die ABSOLUTE UK des Wrappers ermitteln
		uk_wrap = thisObject.getAbsoluteBottom( wrapper_id );
// Die Veraenderung der UK zu der Wrapper-Hoehe addieren
		h_wrap = h_wrap + tiefste_uk - uk_wrap;
		uk_wrap = tiefste_uk;

// evtl Mindesthoehe anpassen
// Dabei h_wrap auf Mindesthoehe erhoehen und die UK um dieses Mass weiter nach unten ziehen.
		if( min_height > 0 )
			if( h_wrap < min_height ) {
				uk_wrap += ( min_height - h_wrap );
				h_wrap = min_height;
			}

// 2.) abhaengige divs anpassen
// Problem: bei PreOnloadTracking beginnen die Abfragen bereits, wenn noch gar nicht alle bound-to-divs da sind. 
// Die Abfrage (h_wrap != h_wrap_alt) fuehrt zum Fehler, wenn h_wrap bereits in einem frueheren Durchgang ohne andere divs auf Mindesthoehe 
// gesetzt wurde und im spaeteren Duchgang die divs existieren, aber bei wenig Inhalt die Mindesthoehe nicht erreichen. In diesem Fall ist 
// die Abfrage true, und es wird faelschlicherweise keine Anpassung der dependents gerechnet.
// Deshalb preOnloadTrack_darst ermitteln (s.o.)
// Bei 	onloadInit wird dann h_wrap_alt nochmal auf Null zurueckgesetzt und somit beim folgenden resize Neuberechnung erzwungen

		if( h_wrap != h_wrap_alt || preOnloadTrack_darst )
		{
			wrapper.style.height = h_wrap + "px";
			h_wrap_alt = h_wrap;
			rueck = true;

			for ( i = 0; i < anz_dep_divs; i++ )
			{
				elem = document.getElementById( dependend_divs[i]["id"] );
				if( ( uk = thisObject.getAbsoluteBottom( dependend_divs[i]["id"] )) >= 0 ) {	// < 0: elem ist null
					h_div = elem.offsetHeight;
					uk += dependend_divs[i]["addwert"];
// Die UK muss (nach Anbringen der evtl Addwert-Korrektur) identisch sein mit der UK des Wrappers
					addiere = uk_wrap - uk;
					document.getElementById( dependend_divs[i]["id"] ).style.height = h_div + addiere + "px";
				}
			}
		}
	return rueck;
	}
}

/*

//alert( wrapper.style.marginLeft );
// 1.) neue Hoehe des Dyn-wrappers ermitteln
		for ( i = 0; i < anz_boundto_divs; i++ )
		{
			abs_y = 0;
			elem = document.getElementById( bound_to_divs[i]["id"] );
			if( elem ) {		// falls element ueberhaupt existiert
				h_div = elem.offsetHeight;
// gehe durch den Elementenbaum bis beim wrapper angekommen
// Summiere die y-Werte auf. Ergibt die absolute Position bezogen auf den wrapper.
				do {
					abs_y = abs_y + elem.offsetTop;
					elem = elem.offsetParent;
				} while( elem != wrapper );
// Unterkante ist Y-Wert + Hoehe + Additionswert
				uk = abs_y + h_div + bound_to_divs[i]["addwert"];
// Merke die tiefste UK, immer die erste
				if( i == 0 || uk > h_wrap )
					h_wrap = uk;
			}
		}
		if( min_height > 0 )
			if( h_wrap < min_height )
				h_wrap = min_height;

// evtl. an window-bottom binden
		if( bot_bound )	{
			window_h = window.innerHeight;
			if( typeof window_h == 'undefined' )
				window_h = document.documentElement.clientHeight;
			if( h_wrap + abst_bot < window_h )
				h_wrap = window_h - abst_bot;
		}

// 2.) abhaengige divs anpassen
		if( h_wrap != h_wrap_alt )
		{
			wrapper.style.height = h_wrap + "px";
			h_wrap_alt = h_wrap;
			rueck = true;

			for ( i = 0; i < anz_dep_divs; i++ )
			{
				abs_y = 0;
				elem = document.getElementById( dependend_divs[i]["id"] );
				if( elem ) {		// falls element ueberhaupt existiert
					h_div = elem.offsetHeight;
// gehe durch den Elementenbaum bis beim wrapper angekommen
// Summiere die y-Werte auf. Ergibt die absolute Position bezogen auf den wrapper.
					do {
						abs_y = abs_y + elem.offsetTop;
						elem = elem.offsetParent;
					} while( elem != wrapper );

					bot =  abs_y + h_div;
					addiere = h_wrap - bot + dependend_divs[i]["addwert"];
					document.getElementById( dependend_divs[i]["id"] ).style.height = h_div + addiere + "px";
				}
			}
			h_wrap_alt = h_wrap;
		}
	return rueck;
	}
*/