/***********************************************************************************************
*			+----------------------------------------------------------------------+
*			|          Speedyware-Webscripting JavaScript Grundfunktionen          |
*			|   von Eike Swat <eike.swat@speedyware.de>, Speedyware-Webscripting   |
*			|                       Include-File Development                       |
*			|                                                                      |
*			+----------------------------------------------------------------------+
*			|                     Copyright (c) 2007 Parrot-Media                  |
*			+----------------------------------------------------------------------+
*
*	@version    0.8 / 28.01.2008
*	@author     Eike Swat <eike.swat@parrot-media.de> für Parrot-Media (http://www.parrot-media.de)
*	@copyright  2008 Parrot-Media
***********************************************************************************************/

/* --- Allgemeine Funktionen --- */

/**
*	Äquivalent zur Funktion in PHP
*/
function in_array(array, needle){
	for(var i=0; i<array.length; i++)
		if(array[i] == needle) return true;
	return false;
}

/**
*	Prüft, ob der Browser Google-Maps-Fähig ist
*/
var G_INCOMPAT = false;
function GoogleMapsBrowserIsCompatible(){
	if (G_INCOMPAT) return false;
	if (!window.RegExp) return false;
	var AGENTS = ["opera","msie","safari","firefox","netscape","mozilla"];
	var agent = navigator.userAgent.toLowerCase();
	for (var i = 0; i < AGENTS.length; i++){
		var agentStr = AGENTS[i];
		if (agent.indexOf(agentStr) != -1){
			if (document.body){
				document.body.className = agentStr;
			}
			var versionExpr = new RegExp(agentStr + "[ \/]?([0-9]+(\.[0-9]+)?)");
			var version = 0;
			if (versionExpr.exec(agent) != null) {
				version = parseFloat(RegExp.$1);
			}
			if (agentStr == "opera") 	return version >= 7;
			if (agentStr == "safari") 	return version >= 125;
			if (agentStr == "msie") 	return (version >= 5.5 && agent.indexOf("powerpc") == -1);
			if (agentStr == "netscape") return version > 7;
			if (agentStr == "firefox") 	return version >= 0.8;
		}
	}
	return !!document.getElementById;
}


/**
*	Prüft, ob die Seite in einem Frame einer anderen Seite aufgerufen wurde und 
*	aktualisiert gegebenenfalls im Parent-Frame neu
*	@param string domain Enthält den Namen der aktuellen Domain
*/
function checkParentFrame(domain){
	url = top.Location.host;
	if(url.toLowerCase().indexOf(domain) == -1){ // Schaut, ob der Domainname in der URL des Frames auftaucht
		top.location.href = "http://www." + domain;
	}
}

/**
*	Gibt die GET-Parameter der aufgerufenen Seite zurück
*	@param string name Gibt den geforderten GET-Parameter an
*/
function getParams(name){
	a = top.location.search;
	a = a.substring(1, a.length); // Fragezeichen abschneiden
	if(a != ''){ // Wenn überhaupt ein GET-String übergeben wurde
		a = a.split("&"); // Am & trennen
		for(i in a){
			a[i] = a[i].split("=");	
			if(name != null && a[i][0] == name)
				return a[i][1];	
		}
		if(name == null) return a;
	}
	return false;
}


/**
*	@param	string id ELEMENT-ID
*	@param	boolean value Gibt den neuen Display-Wert an (true|false/none)
*	@return	boolean	Success
*	Zeigt/versteckt Objekte mit der ID id
*/
function display(id, value){
	if(id == 'undefined' || id == null)
		alert("Error handling hidden mode. Identification undefined.");
	
	if(!document.getElementById(id)) return false;
	
	if(value == null){ // Switchen, wenn kein Wert angegeben wurde
		if(document.getElementById(id).style.display == ''){
			document.getElementById(id).style.display = 'none';
			return false;
		}
		document.getElementById(id).style.display = '';
		return true;
	}

	if(value != 'none' && value != false){
		document.getElementById(id).style.display = '';
		return true;
	}
	
	document.getElementById(id).style.display = 'none';
	return false;
}


/**
*	Wie Display, nur dass kein Rückgabewert gegeben wird
*/
function show(id, value){
    if(id == 'undefined' || id == null)
        alert("Error handling hidden mode. Identification undefined.");
    
    if(document.getElementById(id)){
        if(value == null){ // Switchen, wenn kein Wert angegeben wurde
            if(document.getElementById(id).style.display == '')
                document.getElementById(id).style.display = 'none';
            else
                document.getElementById(id).style.display = '';
        }else{
            if(value != 'none' && value != false)
                document.getElementById(id).style.display = '';
            else
                document.getElementById(id).style.display = 'none';
        }
    }
}

/**
*	Gibt den Wert des Feldes aus, der in einem Select-Field mit der ID "id" ausgewählt wurde
*	@param string id ELEMENT-ID
*	@return int ID
*/
function getSelected(id){
	for(i=0;i<document.getElementById(id).length;++i)
		if(document.getElementById(id).options[i].selected == true)
			return document.getElementById(id).options[i].value;
}

/**
*	Gibt eine Anfrage aus und den Rückgabewert zurück
*	@param string string Ausgabestring
*/
function q(string){
	return comfirm(string);	
}

/* --- Statusleistentexte --- */

/**
*	Diese Funktion schreibt einen Text `text` in die Statusleiste
*/
function statusText(text){
	window.status = text;
}

/**
*	Diese Funktion setzt die Statusleiste auf einen Standardwert zurück, welcher in der globalen Variablen statusDefault gespeichert werden kann
*/
function statusClear(){
	if(statusDefault == null || statusDefault == 'undefined')
		statusDefault = '';
	statusText(statusDefault);	
}


/* --- Dynamische Menüs --- */

/**
*	Diese Funktion lädt alle übergebenen Bilder in den Cache des Browsers vor
*/
function BilderVorladen()
{
    document.Vorladen = new Array();
    if(document.images){
        for(var i = 0; i < BilderVorladen.arguments.length; i++){
            document.Vorladen[i] = new Image();
            document.Vorladen[i].src = BilderVorladen.arguments[i];
        }
    }
}


// ACHTUNG: Hierfür muss vorher im JS-Code ein Array menu erzeugt werden, das die IDs der Menüeinträge enthält
var timeOut; // Enthält das Objekt für den Timeout

// Mögliche Variablenerzegungen und Einstellungen:
//		var menu = new Array('administrazion', 'organisazion', 'kommunikazion', 'innovazion'); // Beispielhaftes Menü
//		document.onclick = menuHide; // Ruft die Funktion zum Verstecken des Menüs beim Click auf die Seite auf

/**
*	Diese Funktion blender den mit der ID 'id' bezeichneten Menüeintrag ein und stoppt den Timer
*	Wenn jedoch keine id übergeben wurde, oder die id 'none' enthält, wird nur der Timer gestopp
*	@param string id ID des Menüeintrags(\d|none/undefinded) (optional)
*/
function menuOver(id){
	menuHide(); // Alle einträge ausblenden
	if(id != "none" && id != 'undefined' && id != null) // Wenn ein Menüeintrag übergeben wurde: Diesen anzeigen
		display(id, true);
}

/**
*	Diese Funktion blendet alle Menüpunkte aus dem Array 'menu' aus, wenn keine id angegeben ist.
*	Ansonsten wird nur der Eintrag mit der ID 'id' ausgeblendet
*	@param string id Name des Menüpunktes, der ausgeblendet werden soll (optional)
*/
function menuHide(id){
	window.clearTimeout(timeOut);
	if(id == 'undefined' || id == null)
		for(var i=0;i<menu.length;i++) // Alle ausblenden
			display(menu[i], false);	
	else // Ansonsten nur den angegebenen ausblenden
		display(id, false);
}

/**
*	Diese Funtion ruft nach der Zeit t in Sekunden (eine Sekunde) die Funktion zum Ausblenden der Einträge auf
*	@param int t Zeit in Sekunden
*/
function menuOut(t){
	if(t == 'undefined' || t == null) t = 1;
	timeOut = window.setTimeout("menuHide()", t * 1000);
}

/*--------------------------------------------------------------------------------------------*/
/*-------------------------------------------- AJAX ------------------------------------------*/
/*--------------------------------------------------------------------------------------------*/
function ajaxPlain(){
	/**
	*	@var Object
	*	Enthält das Object über das die Daten transferiert werden
	*/
	this.request = null;	
	
	if(typeof XMLHttpRequest != 'undefined'){ // Mozilla, Opera, Safari sowie Internet Explorer 7
		this.request = new XMLHttpRequest();
	}
	if(!this.request){ // Internet Explorer 6 und älter
		try {
			this.request  = new ActiveXObject("Msxml2.XMLHTTP");
		}catch(e){
			try{
				this.request  = new ActiveXObject("Microsoft.XMLHTTP");
			}catch(e){
				this.request  = null;
			}
		}
	}
	
	/**
	*	Schnittstelle aufbauen für die Datenberbindung zum Server und Objekt in request ablegen
	*/
	this.constructor = function(){
		if(typeof XMLHttpRequest != 'undefined'){ // Mozilla, Opera, Safari sowie Internet Explorer 7
			this.request = new XMLHttpRequest();
		}
		if(!this.request){ // Internet Explorer 6 und älter
			try {
				this.request  = new ActiveXObject("Msxml2.XMLHTTP");
			}catch(e){
				try{
					this.request  = new ActiveXObject("Microsoft.XMLHTTP");
				}catch(e){
					this.request  = null;
				}
			}
		}
	}
	
	this.getPlain = function(url){
		if(this.request != null){ // Nur wenn eine Schnittstelle besteht
			this.request.open('GET', url, false);
			this.request.send(null);
			return this.request.responseText;
		}
	}
	
	this.postForm = function(url, params){
		if(this.request != null){ // Nur wenn eine Schnittstelle besteht
	        this.request.open('POST', url, false);
			var string = new Array();
			i=0;
			for(name in params){
				string[i++] = name +"="+ encodeURIComponent(params[name]);
			}
			string = string.join("&");
//			this.request.onreadystatechange = handleServerResponse; 
			this.request.setRequestHeader("Content-type", "application/x-www-form-urlencoded"); 
//			this.request.setRequestHeader("Content-length", string.length); 
//			this.request.setRequestHeader("Connection", "close"); 
			this.request.send(string);

			return this.request.responseText;
		}
	}
}

function ajaxXML(){
	/**
	*	@var Object
	*	Enthält das Object über das die Daten transferiert werden
	*/
	this.request;
	
	/**
	*	Diese Funktion ist der Konstruktor des Objekts und ermittelt die beste Methode zum Übertragen der Daten
	*/	
	this.constructor = function(){
		if(window.XMLHttpRequest){
			this.request = new XMLHttpRequest();
		}else if(window.ActiveXObject('Msxml2.XMLHTTP')){
			try{
				this.request = new ActiveXObject('Msxml2.XMLHTTP');
			}catch(e1){
				try{
					this.request = new ActiveXObject('Microsoft.XMLHTTP');
				}catch(e2){}
			}
		}
	}
	
	/**
	*	Diese Funktion für ein Quers zur Seite url über die methode method aus und ruft nach Abschluss die Methode fname auf.
	*	Die Variable as gibt dabei an, ob der Vorgang Synchron oder Asynchron ablaufen soll
	*	@param string method (GET|POST) Methode des Query
	*	@param string url URL des Query
	*	@param string fname Name der aufzurufenden URL
	*	@param boolean as (synchronous|asynchronous)
	*/
	this.query = function(method, url, fname, as){
		if(!as) as = true; // asynchronous per default: true
		if(this.request != null){
			this.request.open(method, url, as);
			this.request.onreadystatechange = fname;
			this.request.send(null);
		}	
	}
	
}

/*--------------------------------------------------------------------------------------------*/
/*------------------------------------------ COOKIES -----------------------------------------*/
/*--------------------------------------------------------------------------------------------*/

/**
*	Setzt ein Cookie mit dem Namen key und dem Wert value. Die Gültigkeit ist dabei in expires in Sekunden angegeben
*	@param string key Name des Cookie
*	@param string value Wert des Cookie
*	@param int expires Anzahl der Sekunden bis das Cookie zerfällt
*/
function cookieWrite(key, value, expires){
	var a = new Date();
	a = new Date(a.getTime() + expires * 1000);
	document.cookie = key + '=' + value + '; expires='+a.toGMTString() + ';';
}

/**
*	Liest ein Cookie mit dem Namen key ein (Aus dem Buch, nicht meine Funktion -> noch ändern, Methode ist komisch)
*	@param string key Name des Cookie
*/
function cookieRead(key){
	a = document.cookie;
	while(a != ''){
		name = a.substring(0, a.indexOf('=')	).replace(' ', '');
		wert = a.substr(a.indexOf('=')+1,a.length);
		if(wer.indexOf(';') > -1){
			wert = wert.substring(0, wert.indexOf(';'));	
		}
		if(name == key)
			return wert;
			
		if(a.indexOf(';') != -1){
			a = a.substring(a.indexOf(';')+1, a.length);
		}
		else{
			return '';
		}
		return '';
	}
}

/**
*	Lösche ein Cookie mit dem Namen key
*	@param string key Name des zu löschenden Cookie
*/
function cookieDelete(key){
	cookieWrite(key, '', -1000000);
}

/*--------------------------------------------------------------------------------------------*/
/*----------------------------------------- ENCODING -----------------------------------------*/
/*--------------------------------------------------------------------------------------------*/
/**
*
* Base64 encode / decode
* http://www.webtoolkit.info/
*
**/

var Base64 = {

    // private property
    _keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",

    // public method for encoding
    encode : function (input) {
        var output = "";
        var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
        var i = 0;

        input = Base64._utf8_encode(input);

        while (i < input.length) {

            chr1 = input.charCodeAt(i++);
            chr2 = input.charCodeAt(i++);
            chr3 = input.charCodeAt(i++);

            enc1 = chr1 >> 2;
            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
            enc4 = chr3 & 63;

            if (isNaN(chr2)) {
                enc3 = enc4 = 64;
            } else if (isNaN(chr3)) {
                enc4 = 64;
            }

            output = output +
            this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) +
            this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);

        }

        return output;
    },

    // public method for decoding
    decode : function (input) {
        var output = "";
        var chr1, chr2, chr3;
        var enc1, enc2, enc3, enc4;
        var i = 0;

        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");

        while (i < input.length) {

            enc1 = this._keyStr.indexOf(input.charAt(i++));
            enc2 = this._keyStr.indexOf(input.charAt(i++));
            enc3 = this._keyStr.indexOf(input.charAt(i++));
            enc4 = this._keyStr.indexOf(input.charAt(i++));

            chr1 = (enc1 << 2) | (enc2 >> 4);
            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
            chr3 = ((enc3 & 3) << 6) | enc4;

            output = output + String.fromCharCode(chr1);

            if (enc3 != 64) {
                output = output + String.fromCharCode(chr2);
            }
            if (enc4 != 64) {
                output = output + String.fromCharCode(chr3);
            }

        }

        output = Base64._utf8_decode(output);

        return output;

    },

    // private method for UTF-8 encoding
    _utf8_encode : function (string) {
        string = string.replace(/\r\n/g,"\n");
        var utftext = "";

        for (var n = 0; n < string.length; n++) {

            var c = string.charCodeAt(n);

            if (c < 128) {
                utftext += String.fromCharCode(c);
            }
            else if((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            }
            else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }

        }

        return utftext;
    },

    // private method for UTF-8 decoding
    _utf8_decode : function (utftext) {
        var string = "";
        var i = 0;
        var c = c1 = c2 = 0;

        while ( i < utftext.length ) {

            c = utftext.charCodeAt(i);

            if (c < 128) {
                string += String.fromCharCode(c);
                i++;
            }
            else if((c > 191) && (c < 224)) {
                c2 = utftext.charCodeAt(i+1);
                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                i += 2;
            }
            else {
                c2 = utftext.charCodeAt(i+1);
                c3 = utftext.charCodeAt(i+2);
                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                i += 3;
            }

        }

        return string;
    }

}

/* Base64 conversion methods.
 * Copyright (c) 2006 by Ali Farhadi.
 * released under the terms of the Gnu Public License.
 * see the GPL for details.
 *
 * Email: ali[at]farhadi[dot]ir
 * Website: http://farhadi.ir/
 */

//Encodes data to Base64 format
function base64_encode(data){
	if (typeof(btoa) == 'function') return btoa(data);//use internal base64 functions if available (gecko only)
	var b64_map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
	var byte1, byte2, byte3;
	var ch1, ch2, ch3, ch4;
	var result = new Array(); //array is used instead of string because in most of browsers working with large arrays is faster than working with large strings
	var j=0;
	for (var i=0; i<data.length; i+=3) {
		byte1 = data.charCodeAt(i);
		byte2 = data.charCodeAt(i+1);
		byte3 = data.charCodeAt(i+2);
		ch1 = byte1 >> 2;
		ch2 = ((byte1 & 3) << 4) | (byte2 >> 4);
		ch3 = ((byte2 & 15) << 2) | (byte3 >> 6);
		ch4 = byte3 & 63;

		if (isNaN(byte2)) {
			ch3 = ch4 = 64;
		} else if (isNaN(byte3)) {
			ch4 = 64;
		}

		result[j++] = b64_map.charAt(ch1)+b64_map.charAt(ch2)+b64_map.charAt(ch3)+b64_map.charAt(ch4);
	}

	return result.join('');
}

//Decodes Base64 formated data
function base64_decode(data){
	data = data.replace(/[^a-z0-9\+\/=]/ig, '');// strip none base64 characters
	if (typeof(atob) == 'function') return atob(data);//use internal base64 functions if available (gecko only)
	var b64_map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
	var byte1, byte2, byte3;
	var ch1, ch2, ch3, ch4;
	var result = new Array(); //array is used instead of string because in most of browsers working with large arrays is faster than working with large strings
	var j=0;
	while ((data.length%4) != 0) {
		data += '=';
	}

	for (var i=0; i<data.length; i+=4) {
		ch1 = b64_map.indexOf(data.charAt(i));
		ch2 = b64_map.indexOf(data.charAt(i+1));
		ch3 = b64_map.indexOf(data.charAt(i+2));
		ch4 = b64_map.indexOf(data.charAt(i+3));

		byte1 = (ch1 << 2) | (ch2 >> 4);
		byte2 = ((ch2 & 15) << 4) | (ch3 >> 2);
		byte3 = ((ch3 & 3) << 6) | ch4;

		result[j++] = String.fromCharCode(byte1);
		if (ch3 != 64) result[j++] = String.fromCharCode(byte2);
		if (ch4 != 64) result[j++] = String.fromCharCode(byte3);
	}

	return result.join('');
}

/*--------------------------------------------------------------------------------------------*/
/*-------------------------------------- DYNAMISIERUNG ---------------------------------------*/
/*--------------------------------------------------------------------------------------------*/
/**
*	Wird von Hauptauswahl-Bildern auferufen bei einem Mouseover:
*	Versetzt die Bilder in den Angewählt-Zustand
*/
function imageSOver(id){
	document.getElementById(id).className = 'imageSOver';
	document.getElementById(id).style.filter = '';
}
/**
*	Versetzt die Bilder wieder in den Normalzustand
*/
function imageSOut(id){
	document.getElementById(id).className = '';
	document.getElementById(id).style.filter = 'Gray()';
}

/**
*	Ruft eine URL auf, die aus einem Select-Field generiert wird
*/
function selectURL(el, url){
	for(var i=0;i<el.length;i++){
		if(el.options[i].selected == true){ // Feld ausgewählt
			url = url.replace("VALUE", el.options[i].value);
			location.href=url;
		}
	}
}

/**
*	Zeigt, wenn ausgelöst, ein Tooltip am Cursor an
*	@param string name: Name des Tooltip-Elements (bei mehreren)
*	@param string text: Textinhalt der Box
*	@param int timToHide: Wenn angegeben und nicht 0, wird das Tooltip nach X Sekunden wieder ausgeblendet
*/
function showToolTip(name, text, timeToHide ){
	
}

/**
*	Versteckt das ToolTip wieder
*/
function hideToolTip(){
		
}




//v1.7
// Flash Player Version Detection
// Detect Client Browser type
// Copyright 2005-2007 Adobe Systems Incorporated.  All rights reserved.
var isIE  = (navigator.appVersion.indexOf("MSIE") != -1) ? true : false;
var isWin = (navigator.appVersion.toLowerCase().indexOf("win") != -1) ? true : false;
var isOpera = (navigator.userAgent.indexOf("Opera") != -1) ? true : false;

function ControlVersion()
{
	var version;
	var axo;
	var e;

	// NOTE : new ActiveXObject(strFoo) throws an exception if strFoo isn't in the registry

	try {
		// version will be set for 7.X or greater players
		axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
		version = axo.GetVariable("$version");
	} catch (e) {
	}

	if (!version)
	{
		try {
			// version will be set for 6.X players only
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
			
			// installed player is some revision of 6.0
			// GetVariable("$version") crashes for versions 6.0.22 through 6.0.29,
			// so we have to be careful. 
			
			// default to the first public version
			version = "WIN 6,0,21,0";

			// throws if AllowScripAccess does not exist (introduced in 6.0r47)		
			axo.AllowScriptAccess = "always";

			// safe to call for 6.0r47 or greater
			version = axo.GetVariable("$version");

		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 4.X or 5.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.3");
			version = axo.GetVariable("$version");
		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 3.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.3");
			version = "WIN 3,0,18,0";
		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 2.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
			version = "WIN 2,0,0,11";
		} catch (e) {
			version = -1;
		}
	}
	
	return version;
}

// JavaScript helper required to detect Flash Player PlugIn version information
function GetSwfVer(){
	// NS/Opera version >= 3 check for Flash plugin in plugin array
	var flashVer = -1;
	
	if (navigator.plugins != null && navigator.plugins.length > 0) {
		if (navigator.plugins["Shockwave Flash 2.0"] || navigator.plugins["Shockwave Flash"]) {
			var swVer2 = navigator.plugins["Shockwave Flash 2.0"] ? " 2.0" : "";
			var flashDescription = navigator.plugins["Shockwave Flash" + swVer2].description;
			var descArray = flashDescription.split(" ");
			var tempArrayMajor = descArray[2].split(".");			
			var versionMajor = tempArrayMajor[0];
			var versionMinor = tempArrayMajor[1];
			var versionRevision = descArray[3];
			if (versionRevision == "") {
				versionRevision = descArray[4];
			}
			if (versionRevision[0] == "d") {
				versionRevision = versionRevision.substring(1);
			} else if (versionRevision[0] == "r") {
				versionRevision = versionRevision.substring(1);
				if (versionRevision.indexOf("d") > 0) {
					versionRevision = versionRevision.substring(0, versionRevision.indexOf("d"));
				}
			}
			var flashVer = versionMajor + "." + versionMinor + "." + versionRevision;
		}
	}
	// MSN/WebTV 2.6 supports Flash 4
	else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.6") != -1) flashVer = 4;
	// WebTV 2.5 supports Flash 3
	else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.5") != -1) flashVer = 3;
	// older WebTV supports Flash 2
	else if (navigator.userAgent.toLowerCase().indexOf("webtv") != -1) flashVer = 2;
	else if ( isIE && isWin && !isOpera ) {
		flashVer = ControlVersion();
	}	
	return flashVer;
}

// When called with reqMajorVer, reqMinorVer, reqRevision returns true if that version or greater is available
function DetectFlashVer(reqMajorVer, reqMinorVer, reqRevision)
{
	versionStr = GetSwfVer();
	if (versionStr == -1 ) {
		return false;
	} else if (versionStr != 0) {
		if(isIE && isWin && !isOpera) {
			// Given "WIN 2,0,0,11"
			tempArray         = versionStr.split(" "); 	// ["WIN", "2,0,0,11"]
			tempString        = tempArray[1];			// "2,0,0,11"
			versionArray      = tempString.split(",");	// ['2', '0', '0', '11']
		} else {
			versionArray      = versionStr.split(".");
		}
		var versionMajor      = versionArray[0];
		var versionMinor      = versionArray[1];
		var versionRevision   = versionArray[2];

        	// is the major.revision >= requested major.revision AND the minor version >= requested minor
		if (versionMajor > parseFloat(reqMajorVer)) {
			return true;
		} else if (versionMajor == parseFloat(reqMajorVer)) {
			if (versionMinor > parseFloat(reqMinorVer))
				return true;
			else if (versionMinor == parseFloat(reqMinorVer)) {
				if (versionRevision >= parseFloat(reqRevision))
					return true;
			}
		}
		return false;
	}
}

function AC_AddExtension(src, ext)
{
  if (src.indexOf('?') != -1)
    return src.replace(/\?/, ext+'?'); 
  else
    return src + ext;
}

function AC_Generateobj(objAttrs, params, embedAttrs) 
{ 
  var str = '';
  if (isIE && isWin && !isOpera)
  {
    str += '<object ';
    for (var i in objAttrs)
    {
      str += i + '="' + objAttrs[i] + '" ';
    }
    str += '>';
    for (var i in params)
    {
      str += '<param name="' + i + '" value="' + params[i] + '" /> ';
    }
    str += '</object>';
  }
  else
  {
    str += '<embed ';
    for (var i in embedAttrs)
    {
      str += i + '="' + embedAttrs[i] + '" ';
    }
    str += '> </embed>';
  }

  document.write(str);
}

function AC_FL_RunContent(){
  var ret = 
    AC_GetArgs
    (  arguments, ".swf", "movie", "clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
     , "application/x-shockwave-flash"
    );
  AC_Generateobj(ret.objAttrs, ret.params, ret.embedAttrs);
}

function AC_SW_RunContent(){
  var ret = 
    AC_GetArgs
    (  arguments, ".dcr", "src", "clsid:166B1BCA-3F9C-11CF-8075-444553540000"
     , null
    );
  AC_Generateobj(ret.objAttrs, ret.params, ret.embedAttrs);
}

function AC_GetArgs(args, ext, srcParamName, classid, mimeType){
  var ret = new Object();
  ret.embedAttrs = new Object();
  ret.params = new Object();
  ret.objAttrs = new Object();
  for (var i=0; i < args.length; i=i+2){
    var currArg = args[i].toLowerCase();    

    switch (currArg){	
      case "classid":
        break;
      case "pluginspage":
        ret.embedAttrs[args[i]] = args[i+1];
        break;
      case "src":
      case "movie":	
        args[i+1] = AC_AddExtension(args[i+1], ext);
        ret.embedAttrs["src"] = args[i+1];
        ret.params[srcParamName] = args[i+1];
        break;
      case "onafterupdate":
      case "onbeforeupdate":
      case "onblur":
      case "oncellchange":
      case "onclick":
      case "ondblClick":
      case "ondrag":
      case "ondragend":
      case "ondragenter":
      case "ondragleave":
      case "ondragover":
      case "ondrop":
      case "onfinish":
      case "onfocus":
      case "onhelp":
      case "onmousedown":
      case "onmouseup":
      case "onmouseover":
      case "onmousemove":
      case "onmouseout":
      case "onkeypress":
      case "onkeydown":
      case "onkeyup":
      case "onload":
      case "onlosecapture":
      case "onpropertychange":
      case "onreadystatechange":
      case "onrowsdelete":
      case "onrowenter":
      case "onrowexit":
      case "onrowsinserted":
      case "onstart":
      case "onscroll":
      case "onbeforeeditfocus":
      case "onactivate":
      case "onbeforedeactivate":
      case "ondeactivate":
      case "type":
      case "codebase":
      case "id":
        ret.objAttrs[args[i]] = args[i+1];
        break;
      case "width":
      case "height":
      case "align":
      case "vspace": 
      case "hspace":
      case "class":
      case "title":
      case "accesskey":
      case "name":
      case "tabindex":
        ret.embedAttrs[args[i]] = ret.objAttrs[args[i]] = args[i+1];
        break;
      default:
        ret.embedAttrs[args[i]] = ret.params[args[i]] = args[i+1];
    }
  }
  ret.objAttrs["classid"] = classid;
  if (mimeType) ret.embedAttrs["type"] = mimeType;
  return ret;
}