/**
 * Dem ContainerControl Objekt werden Container-Id´s übergeben, 
 * die als Zeilen interpretiert werden.
 * Die Zeilen stellen den Rahmen für eine beliebige Spaltenanzahl.
 * Die Spalten einer Zeile werden auf die gleiche Höhe gesetzt.
 * Ausschlaggebend ist die Höhe der höchsten Spalte.
 * 
 * Im Parameter "staticContainer" werden die ID´s der Eltern-Container übergeben, 
 * die eine feste Höhe besitzen.
 * 
 * Der Parameter "dynamicContainer" ist eine einzelne Container-ID und 
 * setzt ebenfalls alle (direkt) darunterliegenden Container (Spalten) auf die gleiche Höhe.
 * Die Höhe ergibt sich aus dem zur Verfügung stehenden Fensterplatz abzüglich der "staticContainer".
 * Wird der "dynamicContainer" genutzt, kann ein "offset" übergeben werden, 
 * welches zusätzlich von der Höhe abgezogen wird.
 * 
 * Dies kann der Fall sein, wenn ein "margin" verwendet wird. 
 * Die automatische Berechnung von margin-top /-bottom ist nicht implementiert, 
 * da es hier zu viele Browserunterschiede gibt.
 * 
 * @param {StringArray} staticContainer: ID´s der Zeilen mit statischer Höhe
 * @param {String} dynamicContainer: ID der Zeile mit dynamischer Höhe
 * @param {int} offset: Wird von der Höhe des "dynamicContainers" abgezogen.
 */
function ContainerControl(staticContainer, dynamicContainer, offset)
{
	this.saStaticContainer=staticContainer;
	this.sDynamicContainer=dynamicContainer;
	this.nOffset=offset;
	if(!this.nOffset)
		this.nOffset=0;
	this.nDynamicContainerMinHeight = 0;
	this.nFrameHeight=0;
};

ContainerControl.prototype.initControl = function(event)
{
	this.computeContainer();
	
	return event;
};

ContainerControl.prototype.resizeControl = function(event)
{
	this.computeDynamicContainer();
	
	return event;
};

/**
 * Berechnet und setzt die Spaltenhöhe aller Container ( siehe Objektbeschreibung ).
 * Initzialisiert die minimal Höhe des "dynamicContainers.
 */
ContainerControl.prototype.computeContainer = function()
{
	this.computeStaticContainer();
	this.computeDynamicContainer();
};

/**
 * Berechnet und setzt die Spaltenhöhe der "staticContainer" ( siehe Objektbeschreibung ).
 * Zu "this.nOffset" wird die kommulierte Höhe hinzugefügt.
 */
ContainerControl.prototype.computeStaticContainer = function()
{
	if(this.saStaticContainer)
	{
		for(var a=0; a<this.saStaticContainer.length; a++)
		{
/*			Spalten des Containers eroieren.
* 			Alle Container (Tags) direkt unterhalb des Eltern-Containers erden als Spalten interpretiert. */
			var columnIDs=this.getColumnIDs(this.saStaticContainer[a]);
			if(columnIDs)
			{
/*				Spaltenhöhe ermitteln. */
				var maxColumnHeight=this.getMaxColumnHeight(columnIDs);
/*				Nutzt der "dynamicContainer" die ganze Fensterhöhe, wird "this.nOffset" davon abgezogen. */
				this.nOffset+=maxColumnHeight;
/*				Spaltenhöhe setzten. */
				this.setContainerColumns(columnIDs, maxColumnHeight+'px');
			}
		}
	}
};

/**
 * Berechnet und setzt die Spaltenhöhe des "dynamicContainer" ( siehe Objektbeschreibung ).
 * "this.nOffset" beinhaltet die Höhe der "staticContainer" UND des im Konstruktor übergebenen offset.
 */
ContainerControl.prototype.computeDynamicContainer = function()
{
/*	Nur ausführen wenn der dynamische Conteiner gesetzt ist und die Höhe des Fensters sich geändert hat */
	if(this.sDynamicContainer && this.nFrameHeight!=document.documentElement.clientHeight)
	{
/*		Initialisierung Mindesthöhe. */
		if(this.nDynamicContainerMinHeight == 0)
			this.nDynamicContainerMinHeight = this.getDynamicContainerMinHeight();

/*		Spalten des Containers eroieren.
 * 		Alle Container (Tags) direkt unterhalb des Eltern-Containers erden als Spalten interpretiert. */
		var columnIDs=this.getColumnIDs(this.sDynamicContainer);
		if(columnIDs)
		{
/*			Fenstergröße speichern */		
			this.nFrameHeight=document.documentElement.clientHeight;
/*			Alles was nicht zum Container gehört von der Fensterhöhe abziehen */
			var containerHeight=this.nFrameHeight-this.nOffset;
/*			Min-Höhe */
			var columnHeight=this.nDynamicContainerMinHeight;
/*			Wenn der Fensterplatz groß genug ist, kann "columnHeight" entsprechend vergrößert werden. */
//			if(columnHeight<containerHeight)
//				columnHeight=containerHeight;
/*			Der Content wird gescrollt wenn er größer als das Fenster ist => Container also immer maximale Größe */
			columnHeight=containerHeight;
/*			Spaltenhöhe setzten. */				
			this.setContainerColumns(columnIDs, columnHeight+'px');
		}
	}
};

/**
 * Setzt alle Container auf die gleiche Höhe (height).
 * @param {StringArray} containerIDs: ContainerID´s.
 * @param {String} height: Höhe der Spalten. Format: Zahl+Einheit. Bsp.: 50px.
 */
ContainerControl.prototype.setContainerColumns = function(containerIDs, height)
{
	for(var b=0; b<containerIDs.length; b++)
	{
		this.setHeight(containerIDs[b], height);
	}
};

/**
 * Gibt die Container-ID´s zurück, die direkt unterhalb des übergebenen Containers (id) liegen.
 * @param {String} containerID: Eltern-Container-ID
 * @return {StringArray} SpaltenID´s
 */
ContainerControl.prototype.getColumnIDs = function(containerID)
{
	var columnIDs=new Array();
	if(document.getElementById(containerID))
	{
/*		Itteriert durch alle Tags, die direkt unterhalb von der "containerID" liegen. */
		var containerNode = document.getElementById(containerID).firstChild;
		while(containerNode!=null)
		{
			if(containerNode.attributes)
			{
/*				Ermittelt die Tag-id und fügt sie dem Array "columnsIDs" hinzu. */
				for(var a=0; a<containerNode.attributes.length; a++)
				{
					if(containerNode.attributes[a].name == 'id')
					{
						columnIDs.push(containerNode.attributes[a].value);
						break;
					}
				}
			}
			containerNode = containerNode.nextSibling;
		}
	}
	return columnIDs;
};

/**
 * Setzt die Höhe des übergebenen Containers (id) auf "maxHeight".
 * @param {String} id: Container-Id.
 * @param {int} maxHeight: Höhe des Containers.
 */
ContainerControl.prototype.setHeight = function(id, maxHeight)
{
	if(document.getElementById(id))
		document.getElementById(id).style.height= maxHeight;
};

/**
 * Gibt die Höhe des übergebenen Containers (id) zurück;
 * @param {String} id: Container-Id.
 * @return {int} Höhe des Containers.
 */
ContainerControl.prototype.getContainerHeight = function(id)
{
	var max=0;
		
	if(document.getElementById(id) && max<document.getElementById(id).clientHeight)
		max=document.getElementById(id).clientHeight;
	
	return max;
};

/**
 * Gibt die Mindesthöhe (Höhe der höchsten Spalte) zurück.
 * @return {int} Mindesthöhe des dynamischen Containers.
 */
ContainerControl.prototype.getDynamicContainerMinHeight = function()
{
	var maxColumnHeight=0;
	
/*	Nur ausführen wenn der dynamische Conteiner gesetzt ist */
	if(this.sDynamicContainer)
	{
		var columnIDs=this.getColumnIDs(this.sDynamicContainer);
		if(columnIDs)
			maxColumnHeight = this.getMaxColumnHeight(columnIDs);
	}
	
	return maxColumnHeight;
};

/**
 * Gibt die Höhe des höchsten Containers zurück;
 * @param {String} containerId: Eltern-Container.
 * @param {StringArray} columnIDs: Spalten-Id´s.
 * @return {int} Max-Höhe.
 */
ContainerControl.prototype.getMaxColumnHeight = function(columnIDs)
{
	var max=0;

	for(var a=0; a<columnIDs.length; a++)
	{
		if(document.getElementById(columnIDs[a]) && max<document.getElementById(columnIDs[a]).clientHeight)
			max=document.getElementById(columnIDs[a]).clientHeight;
	}
	return max;
};

ContainerControl.prototype.setMinWidth = function(minWidth)
{
	var browser = navigator.appName;
	
	if(browser.toLocaleLowerCase().search('microsoft') != -1)
	{
		var containerNode = document.getElementsByTagName('BODY');
		
		if(document.documentElement.clientWidth < minWidth)
			containerNode[0].style.width=minWidth;
		else if(containerNode[0].style.width != 'auto')
			containerNode[0].style.width='auto';
	}
};