/**
 * SRH-Hochschulen: Grundlegende Javascript-Funktionen
 *  
 * Zu Empfehlen ist nach Änderungen ein Überprüfen der Javascript-Syntax über
 * das Tool JSlint (http://jslint.com/). 
 * 
 * @author Chris Müller <mueller@cyperfection.de> 
 * @version $Id: srh.js 998 2010-07-15 14:33:13Z christian $
 * @package srh_hs  
 */ 

/*jslint
	bitwise: true,
	browser: true,
	eqeqeq: true,
	immed: true,
	newcap: true,
	nomen: true,
	onevar: true,
	plusplus: true,
	regexp: true,
	undef: true
*/
/*global
	$,
	$$,
	Effect,
	Event,

	escape,
	unescape,

	window
*/


/***** Konstanten *************************************************************/

var SrhConfig = {
	// Header
	header: {
		// Website-Selektor Portal
		sites: {
			// Selector-ID der Box ("Unsere Hochschulen")
			boxId: 'header-sites-box',
			
			// Selector-ID der Auswahl
			optId: 'header-sites-opt',

			// Offset für das Schließen der Optionen, falls Maus aus der Box
			// bewegt wird (in px)
			moveOffset: 10
		},

		wrapperId: 'header-wrapper'
	},

	// Schriftvergrößerung
	fontsize: {
		// ID des Bereichs auf der Startseite, der vergrößert werden soll
		contentHomeId: 'content',

		// ID des Bereichs auf den Unterseiten, der vergrößert werden soll
		contentSubId: 'content',

		// Classes von Bereichen, die nicht vergrößert werden sollen (kommasepariert, ohne Leerzeichen)
		noSizingClasses: 'gallery-functions-top,gallery-functions-bottom,team-list-functions',

		// ID des Bereichs, in dem die Grafiken stehen (für Vergrößerung)
		fontsizeId: 'header-fontsize',

		// Anzahl der Schritte
		steps: 3,

		// Selector-IDs für die einzelnen Schriftgrößen
		actionId: {
			'0': 'header-fontsize-0',
			'1': 'header-fontsize-1',
			'2': 'header-fontsize-2'
		},

		// Schriftgrößen
		size: {
			'0': '100%',
			'1': '120%',
			'2': '140%'
		},

		// Schriftgrößen für Bereiche, die nicht vergrößert werden sollen
		// die obigen Größen werden neutralisiert
		noSize: {
			'0': '100%',
			'1': '85%',
			'2': '70%'
		},

		// Cookie-Name
		cookieName: 'srh_fontsize',

		// Dateinamen der inaktiven Bilder
		image: {
			'0': 'fontsize_0.gif',
			'1': 'fontsize_1.gif',
			'2': 'fontsize_2.gif'
		},
		
		// Dateinamen der aktiven Bilder
		imageAct: {
			'0': 'fontsize_0_act.gif',
			'1': 'fontsize_1_act.gif',
			'2': 'fontsize_2_act.gif'
		}
	},

	// Portal
	portal: {
		// ID des divs, innerhalb dessen das Flash eingebunden ist
		contentHomeId: 'content-home-portal',

		// Id des object-Tags, der das Flash einbindet
		flashObjectId: 'studiumfinder-flash',

		// max. Höhe des Flash
		// muß synchron mit der object-Höhe im HTML sein
		// @see fileadmin/templates/setup/ts/setup/lib.content_home_portal.ts
		maxFlashHeight: 612,

		// min. Höhe des Flash
		minFlashHeight: 410
	},

	// Sitemap
	sitemap: {
		// Selektor-ID der Sitemap
		id: 'csc-sitemap',

		// zusammengefaltete Ebenen (Klassen)
		foldedClasses: 'level-3,level-4,level-5,level-6,level-7',

		// Bildpfad für die aufgeklappte Ebene
		imgPlus: 'fileadmin/templates/media/images/shared/sitemap_plus.gif',

		// Bildpfad für die zugeklappte Ebene
		imgMinus: 'fileadmin/templates/media/images/shared/sitemap_minus.gif'
	},

	// FAQ
	faq: {
		// CSS-Klasse des Headers
		// @see fileadmin/templates/setup/ts/lib.ts
		headerClass: 'h3.faq-header',

		// CSS-Klasse des Inhalts
		// @see fileadmin/templates/setup/ts/tt_content.ts
		contentClass: 'div.faq-content',

		// CSS-Klasse für eine aufgeklappte FAQ
		openedClass: 'faq-header-minus',

		// CSS-Klasse für eine zugeklappte FAQ
		collapsedClass: 'faq-header-plus',

		// Selektor-ID für "Alles aufklappen"
		openAllId: 'faq-open',

		// Selektor-ID für "Alles zuklappen"
		collapseAllId: 'faq-collapse',

		// Zeitdauer für den Slide
		slideDuration: 0.5
	}
};


/***** Verarbeitung ***********************************************************/

function Srh() {
	/***** Variablen **********************************************************/

	/**
	 * Alte Viewport-Höhe
	 * Wird benötigt von portalResizeFlash()
	 * @type Number
	 */
	var oldFlashHeight = SrhConfig.portal.maxFlashHeight;



	/***** Schriftvergößerung *************************************************/

	/**
	 * Schriftgröße setzen
	 * @param {Number} Schriftgröße für CSS-Style-Attribute	 
	 * @param {Number} Schriftgröße für Elemente, die nicht vergrößert werden sollen	 
	 */
	function setFontsize(size, noSize) {
		// Relative CSS-Schriftgröße setzen
		if ($(SrhConfig.fontsize.contentSubId)) {
			// Selektor existiert, wir sind auf einer Unterseite
			$(SrhConfig.fontsize.contentSubId).setStyle({ fontSize: size });
		} else if ($(SrhConfig.fontsize.contentHomeId)) {
			// Selektor nicht vorhanden, wir sollten auf der Startseite sein
			$(SrhConfig.fontsize.contentHomeId).setStyle({ fontSize: size });
		}

		// Gibt es Bereiche innerhalb der Selektoren, die nicht
		// vergrößert werden sollen?
		SrhConfig.fontsize.noSizingClasses.split(',').each(function(selector) {
			$$('.' + selector).each(function(element) {
				$(element).setStyle({ fontSize: noSize });
			});
		});
	}


	/**
	 * Schriftgrößen-Icons aktivieren bzw. deaktivieren
	 * @param {String} Selektor-ID des zu aktivierenden Icons
	 */
	function setFontsizeIcon(id) {
		/**
		 * Dateipfad eines Bildes
		 * @type String
		 */
		var src,

		/**
		 * Position des Beginns des entsprechendes Bilddateinamens
		 * @type Number
		 */
		last,

		/**
		 * Zählvariable
		 * @type Number
		 */
		i;


		// Schleife über alle Schriftvergrößerung
		for (i = 0; i < SrhConfig.fontsize.steps; i += 1) {
			// Bildpfad ermitteln
			src = $(SrhConfig.fontsize.actionId[i.toString()]).src;

			if (id === SrhConfig.fontsize.actionId[i.toString()]) {
				// Aktivierte Schriftgröße
				last = src.lastIndexOf(SrhConfig.fontsize.image[i.toString()]);
				if (last > 0) {
					$(SrhConfig.fontsize.actionId[i.toString()]).src = src.substring(0, last) + SrhConfig.fontsize.imageAct[i.toString()];
				}
			} else {
				// Inaktive Schriftgrößen
				last = src.lastIndexOf(SrhConfig.fontsize.imageAct[i.toString()]);
				if (last > 0) {
					// Schriftgröße war bisher aktiviert
					$(SrhConfig.fontsize.actionId[i.toString()]).src = src.substring(0, last) + SrhConfig.fontsize.image[i.toString()];
				}
			}
		}
	}



	/**
	 * Schrift vergrößern, falls notwendig
	 * @private
	 */
	function fontsizeCheck() {
		/**
		 * Alle Cookies der Domain
		 * @type Array
		 */
		var allCookies,

		/**
		 * Aktueller Cookie
		 * @type String
		 */
		cookie,
		
		/**
		 * Wert des Cookie
		 * @type String		 
		 */
		value,

		/**
		 * Flag, ob Cookie vorhanden und gültig
		 * @type Boolean		 
		 */
		cookieOkay = false,

		/**
		 * Zählvariablen
		 * @type Number
		 */
		i, j,

		/**
		 * Hilfsvariable: Länge Array
		 * @type Number
		 */
		len;


		// Alle Cookies auslesen
		allCookies = document.cookie.split(';');

		len = allCookies.length;
		for (i = 0; i < len; i += 1) {
			cookie = allCookies[i].strip();
			if (cookie.startsWith(SrhConfig.fontsize.cookieName + '=')) {
				// Hier haben wir den korrekten Cookie und bestimmen nun den Wert
				value = unescape(cookie.substr(SrhConfig.fontsize.cookieName.length + 1));

				for (j = 0; j < SrhConfig.fontsize.steps; j += 1) {
					if (value === SrhConfig.fontsize.size[j.toString()]) {
						// Schriftgröße setzen ...
						setFontsize(value, SrhConfig.fontsize.noSize[j.toString()]);

						// ... und Icon aktivieren
						setFontsizeIcon(SrhConfig.fontsize.actionId[j.toString()]);

						// Cookie ist okay
						cookieOkay = true;
					}
				}
			}
		}

		if (cookieOkay === false) {
			// Cookie nicht gesetzt bedeutet Standardschriftgröße
			// Wir aktivieren nun das entsprechende Icon
			setFontsizeIcon(SrhConfig.fontsize.actionId['0']);
		}
	}



	/**
	 * Callback-Funktion beim Klick auf die Schriftgrößenauswahl
	 * @param {Event}
	 * @private
	 */
	function fontsizeClick(e) {

		/**
		 * DOM-Element des Klicks
		 * @type Element
		 */
		var elem = null,

		/**
		 * Selector-ID des angeklickten Bildes
		 * @type String
		 */		
		imgId = '',

		/**
		 * Zählvariable
		 * @type Number
		 */
		i;


		// Verarbeitung stoppen
		e.stop();

		// DOM-Element des Klicks ermitteln
		elem = e.element();

		if (elem.tagName === 'IMG') {
			imgId = elem.identify();

			for (i = 0; i < SrhConfig.fontsize.steps; i += 1) {
				if (imgId === SrhConfig.fontsize.actionId[i.toString()]) {
					// Schriftgröße anpassen
					setFontsize(SrhConfig.fontsize.size[i.toString()],
					            SrhConfig.fontsize.noSize[i.toString()]);

					// Schriftgrößen-Symbol aktivieren
					setFontsizeIcon(imgId);

					// Cookie setzen
					document.cookie = SrhConfig.fontsize.cookieName + "=" + escape(SrhConfig.fontsize.size[i.toString()]) + '; path=/';
				}
			}
		}
	}



	/***** Website-Auswahl ****************************************************/

	function sitesMouseMove(e) {
		/**
		 * Offset der Optionsbox
		 * @type Array
		 */
		var optOffset,

		/**
		 * Dimension der Optionsbox
		 * @type Object	 
		 */
		optDimensions,

		/**
		 * Offset der "Unsere Hochschulen"-Box
		 * @type Array
		 */
		boxOffset,

		/**
		 * Flag, ob Observer gestoppt werden soll
		 * @type Boolean
		 */
		stopObserver;


		optOffset = $(SrhConfig.header.sites.optId).cumulativeOffset();
		optDimensions = $(SrhConfig.header.sites.optId).getDimensions();
		boxOffset = $(SrhConfig.header.sites.boxId).cumulativeOffset();

		stopObserver = false;


		if (e.pointerX() < (optOffset[0] - SrhConfig.header.sites.moveOffset)) {
			// Aktuelle X-Position ist kleiner als linker Rand der Optionsbox
			stopObserver = true;
		} else if (e.pointerX() > (optOffset[0] + optDimensions.width + SrhConfig.header.sites.moveOffset)) {
			// Aktuelle X-Position ist größer als rechter Rand der Optionsbox
			stopObserver = true;
		} else if (e.pointerY() < (boxOffset[1] - SrhConfig.header.sites.moveOffset)) {
			// Aktuelle Y-Position ist kleiner als oberer Rand der Optionsbox
			stopObserver = true;
		} else if (e.pointerY() > (optOffset[1] + optDimensions.height + SrhConfig.header.sites.moveOffset)) {
			// Aktuelle Y-Position ist größer als unterer Rand der Optionsbox
			stopObserver = true;
		}

		if (stopObserver === true) {
			Event.stopObserving(document, 'mousemove');
			$(SrhConfig.header.sites.optId).hide();
		}
	}



	/**
	 * Callback-Funktion beim Klick auf die Website-Auswahl
	 * Es öffnet bzw. schließt sich die Box mit den vorhandenen Websites	 
	 * @param {Event}
	 * @private
	 */
	function sitesBoxClick(e) {
		// Verarbeitung stoppen
		e.stop();

		if ($(SrhConfig.header.sites.optId).visible()) {
			$(SrhConfig.header.sites.optId).hide();
			Event.stopObserving(document, 'mousemove');
		} else {
			$(SrhConfig.header.sites.optId).show();
			document.observe('mousemove', sitesMouseMove);
		}
	}



	/**
	 * Callback-Funktion beim Klick auf die Website-Auswahl
	 * Wurde ein Link angeklickt wird die Box geschlossen	 
	 * @param {Event}
	 * @private
	 */
	function sitesOptClick(e) {
		/**
		 * Angeklicktes Element
		 * @type Element		 
		 */
		var elem;


		// DOM-Element des Klicks ermitteln
		elem = e.element();

		if (elem.tagName === 'A') {
			$(SrhConfig.header.sites.optId).hide();
		}
	}



	/**
	 * Event-Handler für Website-Umschalter erstellen
	 * @private
	 */
	function sitesSetEventHandler() {
		// Klick auf Box "Unsere Hochschule"
		$(SrhConfig.header.sites.boxId).observe('click', sitesBoxClick);

		// Klick auf Optionen
		$(SrhConfig.header.sites.optId).observe('click', sitesOptClick);
	}


	/***** Sitemap ************************************************************/

	/**
	 * Sitemap zusammenfalten
	 * @param void
	 * @private
	 */
	function foldSitemap() {
		/**
		 * Die einzelnen CSS-Klassen
		 * @type Array	 
		 */
		var classes, levelClasses,

		/**
		 * Anzahl der CSS-Klassen
		 * @type Number
		 */
		len, lenLevel,

		/**
		 * Hilfsvariablen
		 * @type Number
		 */
		i, j;


		classes = SrhConfig.sitemap.foldedClasses.split(',');
		len = classes.length;

		for (i = 0; i < len; i += 1) {
			levelClasses = $$('#' + SrhConfig.sitemap.id + ' ul.' + classes[i]);

			lenLevel = levelClasses.length;
			for (j = 0; j < lenLevel; j += 1) {
				levelClasses[j].hide();
			}

		}

	}



	/**
	 * Callback-Funktion beim Klick auf Sitemap
	 * Es öffnet bzw. schließt sich die entsprechende Ebene	 
	 * @param {Event}
	 * @private
	 */
	function sitemapClick(e) {
		/**
		 * Angeklicktes Element
		 * @type Element		 
		 */
		var elem,

		/**
		 * ul-Element der untergeordneten Liste
		 * @type Element
		 */
		ul;


		// DOM-Element des Klicks ermitteln
		elem = e.element();

		if (elem.tagName === 'IMG') {
			ul = elem.next('ul');

			if (ul) {
				if ($(ul).visible()) {
					$(ul).hide();
					elem.src = SrhConfig.sitemap.imgPlus;
				} else {
					$(ul).show();
					elem.src = SrhConfig.sitemap.imgMinus;
				}
			}
		}
	}



	/***** FAQ ****************************************************************/

	/**
	 * Hilfsfunktion zum Ermitteln des entsprechenden FAQ-Inhaltsknotens
	 * @param {Element} Header-Element
	 * @return {Element} Inhalts-Knoten
	 * @private
	 */
	function getFaqContentElement(faqHeader) {
		return faqHeader.up().next(SrhConfig.faq.contentClass);
	}



	/**
	 * FAQ-Content verbergen
	 * @param {Element} FAQ-Header
	 * @param {Element} FAQ-Content	 
	 * @private	 
	 */
	function faqCollapseElement(faqHeader, faqContent) {
		// Inhalt einfahren
		Effect.SlideUp(
			faqContent.identify(),
			{ duration: SrhConfig.faq.slideDuration }
		);

		// Klassen nach dem Slide austauschen (+/-)
		window.setTimeout(
			function() {
				faqHeader.removeClassName(SrhConfig.faq.openedClass);
				faqHeader.addClassName(SrhConfig.faq.collapsedClass);
			},
			SrhConfig.faq.slideDuration*1000
		);
	}



	/**
	 * FAQ-Content öffnen
	 * @param {Element} FAQ-Header
	 * @param {Element} FAQ-Content	 
	 * @private	 
	 */
	function faqOpenElement(faqHeader, faqContent) {
		// Inhalt ausfahren
		Effect.SlideDown(
			faqContent.identify(),
			{ duration: SrhConfig.faq.slideDuration }
		);

		// Klassen nach dem Slide austauschen (+/-)
		window.setTimeout(
			function() {
				faqHeader.removeClassName(SrhConfig.faq.collapsedClass);
				faqHeader.addClassName(SrhConfig.faq.openedClass);
			},
			SrhConfig.faq.slideDuration*1000
		);
	}



	/**
	 * Callback-Funktion beim Klick auf einen "Alles aufklappen"
	 * Es öffnen sich alle FAQ-Contents
	 * @param {Event}
	 * @private
	 */
	function faqOpenAll(e) {
		/**
		 * Alle FAQ-Header, falls vorhanden
		 * @type Array
		 */
		var faqHeaders,

		/**
		 * Inhalt eines FAQ-Content-Elements
		 * @type Element
		 */
		faqContent,

		/**
		 * Hilfsvariablen		 
		 */
		i, len;


		// Wir holen uns jetzt die FAQ-Headers
		faqHeaders = $$(SrhConfig.faq.headerClass);

		len = faqHeaders.length;

		for (i = 0; i < len; i += 1) {
			// Entsprechendes Content-Element
			faqContent = getFaqContentElement(faqHeaders[i]);

			if (!faqContent.visible()) {
				faqOpenElement(faqHeaders[i], faqContent);
			}
		}
	}



	/**
	 * Callback-Funktion beim Klick auf einen "Alles zuklappen"
	 * Es schließen sich alle FAQ-Contents
	 * @param {Event}
	 * @private
	 */
	function faqCollapseAll(e) {
		/**
		 * Alle FAQ-Header, falls vorhanden
		 * @type Array
		 */
		var faqHeaders,

		/**
		 * Inhalt eines FAQ-Content-Elements
		 * @type Element
		 */
		faqContent,

		/**
		 * Hilfsvariablen		 
		 */
		i, len;


		// Wir holen uns jetzt die FAQ-Headers
		faqHeaders = $$(SrhConfig.faq.headerClass);

		len = faqHeaders.length;

		for (i = 0; i < len; i += 1) {
			// Entsprechendes Content-Element
			faqContent = getFaqContentElement(faqHeaders[i]);

			if (faqContent.visible()) {
				faqCollapseElement(faqHeaders[i], faqContent);
			}
		}
	}



	/**
	 * Callback-Funktion beim Klick auf einen FAQ-Header
	 * Es öffnet bzw. schließt sich der entsprechende Inhalt	 
	 * @param {Event}
	 * @private
	 */
	function faqHeaderClick(e) {
		/**
		 * Angeklickter Header
		 * @type Element		 
		 */
		var faqHeader,

		/**
		 * Dazugehöriges Content-Element
		 * @type Element
		 */
		faqContent;


		// DOM-Element des Klicks ermitteln
		faqHeader = e.element();

		// Entsprechendes Content-Element
		faqContent = getFaqContentElement(faqHeader);

		if (faqContent.visible()) {
			faqCollapseElement(faqHeader, faqContent);
		} else {
			faqOpenElement(faqHeader, faqContent);
		}
	}



	/**
	 * FAQ zusammenfalten
	 * @param void
	 * @private
	 */
	function foldFaq() {
		/**
		 * Alle FAQ-Header, falls vorhanden
		 * @type Array
		 */
		var faqHeaders,

		/**
		 * Inhalt eines FAQ-Content-Elements
		 * @type Element
		 */
		faqContent,

		/**
		 * Hilfsvariablen		 
		 */
		i, len;


		// Wir holen uns jetzt die FAQ-Headers
		faqHeaders = $$(SrhConfig.faq.headerClass);

		len = faqHeaders.length;

		if (len === 0) {
			return;
		}

		// Oberhalb des ersten Eintrags kommt eine Leiste für "Alles einklappen"
		// und "Alles Ausklappen"
		faqHeaders[0].insert({
			'before':
			'<div class="faq-panel">' +
				'<ul>' +
					'<li id="faq-open">Alles aufklappen</li>' +
					'<li id="faq-collapse">Alles zuklappen</li>' +
				'</ul>' +
			'</div>'
		});

		// ... und Observer drauflegen
		$(SrhConfig.faq.openAllId).observe('click', faqOpenAll);
		$(SrhConfig.faq.collapseAllId).observe('click', faqCollapseAll);

		for (i = 0; i < len; i += 1) {
			// Jetzt holen wir uns den nächsten Inhaltsknoten ...
			faqContent = getFaqContentElement(faqHeaders[i]);

			if (faqContent) {
				// ... und verstecken diesen
				faqContent.hide();

				// Klasse ergänzen, die das Plus-Symbol darstellt
				faqHeaders[i].addClassName(SrhConfig.faq.collapsedClass);
	
				// Noch einen Observer auf den Klick
				// und fertig ist das Meisterwerk
				faqHeaders[i].observe('click', faqHeaderClick);
			}
		}
	}



	/***** Portal-Flash *******************************************************/

	/**
	 * Überprüfung, ob sich Viewport-Höhe geändert hat
	 * Falls ja, wird das Flash in der Höhe angepasst
	 * @param void
	 * @public
	 */
	this.portalResizeFlash = function() {
		/**
		 * Aktuelle Flash-Höhe
		 * @type Number
		 */
		var flashHeight,

		/**
		 * Flash-Object
		 * @type Element
		 */
		flashObject;

		// Der Headerbereich wird vom Viewport abgezogen und ein eventuelles Scrollen berücksichtigt
		flashHeight = document.viewport.getHeight() - $(SrhConfig.header.wrapperId).getHeight()	+ document.viewport.getScrollOffsets().top;

		if (flashHeight > SrhConfig.portal.maxFlashHeight) {
			flashHeight = SrhConfig.portal.maxFlashHeight;
		}

		if (flashHeight < SrhConfig.portal.minFlashHeight) {
			flashHeight = SrhConfig.portal.minFlashHeight;
		}

		if (oldFlashHeight === flashHeight) {
			// Nur die Breite wurde geändert
			return;
		}

		// Jetzt holen wir uns das Flash-Object ...
		flashObject = $(SrhConfig.portal.flashObjectId);

		// ... und schauen ob wir was machen müssen
		if ((oldFlashHeight <= SrhConfig.portal.maxFlashHeight) && (flashHeight < SrhConfig.portal.maxFlashHeight)) {
			flashObject.stageResize(flashHeight);
			oldFlashHeight = flashHeight;
		} else if (oldFlashHeight < SrhConfig.portal.maxFlashHeight) {
			flashObject.stageResize(SrhConfig.portal.maxFlashHeight);
			oldFlashHeight = SrhConfig.portal.maxFlashHeight;
		}
	};



	/***** Initialisierung ****************************************************/

	/**
	 * Initialisierung
	 * Diese Funktion wird aufgerufen, sobald die HTML-Seite fertig geladen ist
	 * @public
	 */
	this.init = function () {
		/* Schrift vergrößern? */
		if ($(SrhConfig.fontsize.actionId[0])) {
			fontsizeCheck();
		}

		/* Schriftvergrößerung in der Topnavigation */
		if ($(SrhConfig.fontsize.fontsizeId)) {
			$(SrhConfig.fontsize.fontsizeId).observe('click', fontsizeClick);
		}

		/* Sprachauswahl in der Topnavigation */
		if ($(SrhConfig.header.sites.boxId) && $(SrhConfig.header.sites.optId)) {
			sitesSetEventHandler();
		}

		/* Sitemap existiert? */
		if ($(SrhConfig.sitemap.id)) {
			foldSitemap();
			$(SrhConfig.sitemap.id).observe('click', sitemapClick);
		}

		/* FAQ zusammenklappen, falls vorhanden */
		foldFaq();
	};
}



/***** Verarbeitung starten ***************************************************/
document.observe('dom:loaded', function() {
	var srh = new Srh();
	srh.init();

	/* Flash-Resize auf der Portal-Startseite */
	if ($(SrhConfig.portal.contentHomeId)) {
		// Wenn sich die Größe des Viewports ändert, mach was ...
		window.onresize = function() {
			srh.portalResizeFlash();
		};

		// und auch, wenn der Benutzer scrollt
		window.onscroll = function() {
			srh.portalResizeFlash();
		};
	}
});



/***** Wrapper ****************************************************************/

/**
 * Diese Funktion wird direkt aus dem Flash aufgerufen, wenn das Flash
 * komplett geladen ist und dient als Wrapper für den Aufruf innerhalb des
 * Objekts
 */
function portalResizeFlash() {
	var srh = new Srh();
	srh.portalResizeFlash();
}