var homePageFlashMovie;
var testDiv;
var fadeSteps;
var zoomSteps;
fadeSteps=12;
zoomSteps=12;

var topStageNumber;

var tsnVisible = true;

function toggleVisibilityTSN() {
    if (tsnVisible) {
        visibilityTSNoff();
    } else {
        visibilityTSNon();
    }
}

function visibilityTSNon() {
    topStageNavigationMaskDiv.style.height="92px";
    tsnVisible=true;
}

function visibilityTSNoff() {
    topStageNavigationMaskDiv.style.height="1px";
    tsnVisible=false;
}

swfUrl=new Array();
swfTarget=new Array();
swfTracking=new Array();
swfOptionalWindowOpenParameters=new Array();
swfFlashControlFunction=new Array();
swfFlashReadyFunction=new Array();
swfFlashTrackingFunction=new Array();
swfFlashResizeFunction=new Array();
swfFlashOpenFunction=new Array();
swfFlashCloseFunction=new Array();
collapsedStageHeight=new Array();
expandedStageHeight=new Array();
function handleURL(urlNr) {
    sendTrackingRequest('ghppromo',swfTracking[topStageNumber][urlNr]);
    window.open(swfUrl[topStageNumber][urlNr],swfTarget[topStageNumber][urlNr],swfOptionalWindowOpenParameters[topStageNumber][urlNr]);
}
function externalFlashControl(mode) {
    swfFlashControlFunction[topStageNumber](mode);
}
function trackFromFlash(flashTrackValue) {
    swfFlashTrackingFunction[topStageNumber](flashTrackValue);
}
function flashReady() {
    swfFlashReadyFunction[topStageNumber]();
}
function resizeTopStage() {
    toggleVisibilityTSN();
    swfFlashResizeFunction[topStageNumber]();
}
function openStage() {
    visibilityTSNoff();
    swfFlashOpenFunction[topStageNumber]();
}
function closeStage() {
    visibilityTSNon();    
    swfFlashCloseFunction[topStageNumber]();
}

function performanceCheck() {
    try {
        testDiv = document.createElement("DIV");
        testDiv.id="testDiv";
        testDiv.style.display="none";
        testDiv.style.height="1px";
        testDiv.style.width="1px";
        document.body.appendChild(testDiv);
        testDiv.innerHTML=document.body.innerHTML;
        time1=parseInt(new Date().getTime());
        zoomElement('testDiv',1,1,5,1,5,10,'','performanceEvaluate(time1);');
    } catch(e) {}
}
function performanceEvaluate(time1) {
    document.body.removeChild(testDiv);
    time2=parseInt(new Date().getTime());
    performance=time2-time1;
    if (performance<50) {
        fadeSteps=30;
        zoomSteps=30;
    } else if (performance<100) {
        fadeSteps=22;
        zoomSteps=22;
    } else if (performance<200) {
        fadeSteps=16;
        zoomSteps=16;
    } else if (performance<350) {
        fadeSteps=12;
        zoomSteps=12;
    } else if (performance<800) {
        fadeSteps=8;
        zoomSteps=8;
    } else {
        fadeSteps=5;
        zoomSteps=5;
    }
}
var zoomTimer  = new Array();
var zoomActive  = new Array();
var zoomObjStartWidth = new Object();
var zoomObjDeltaWidth = new Object();
var zoomObjStartHeight = new Object();
var zoomObjDeltaHeight = new Object();
var zoomObjSteps = new Object();
var zoomObjStatus = new Object();

zoomObjectsInPage=new Array();
/**********************************************
close all zoomed objects in page but the one with id ownID
**********************************************/
function closeOtherZooms(ownID) {
    for (i=0; i<zoomObjectsInPage.length; i++) {
        if (ownID!=zoomObjectsInPage[i]) {
            if (zoomObjStatus[zoomObjectsInPage[i]]=="max") {
                toggleClass(zoomObjectsInPage[i],'active');
                startZoom(zoomObjectsInPage[i]);
            }
        }
    }
}
/**********************************************
prepare zooming before calling the 'real' zoom function zoomElement
parameters:
objid : id of obkject to zoom
stw: start width in pixels
deltaw: delta width, how many pixels do you want to zoom? 
sth: start height
deltah: delta height
stp: steps - in how many steps is the zooming effect to be realised? currently not functional as nr of steps is defined by performancechecker function
execbefore: javascript to execute before zooming starts
execafter: javascript to execute after zooming is finished
note: if the function is called a second time for teh same object, it will zoom automatically back to the initial size, the third call will resize automatically to the size that was defined in the first call, and so on.
this is done by saving the height and width values in the zoomObj... objects.
**********************************************/
function startZoom(objId,stw,deltaw,sth,deltah,stp,execbefore,execafter) {
    if (!document.getElementById(objId).parentNode.style.zIndex || document.getElementById(objId).parentNode.style.zIndex<2) document.getElementById(objId).parentNode.style.zIndex=2;
    if(!zoomObjStartWidth[objId]) {
        zoomObjStartWidth[objId]=stw;
        zoomObjDeltaWidth[objId]=deltaw;
        zoomObjStartHeight[objId]=sth;
        zoomObjDeltaHeight[objId]=deltah;
        zoomObjSteps[objId]=stp;
    }
    if (zoomObjDeltaHeight[objId]>0) {zoomObjStatus[objId]="max";} else {zoomObjStatus[objId]="min";}
    if (zoomSteps) zoomObjSteps[objId]=zoomSteps;
    zoomElement(objId,0,zoomObjStartWidth[objId],zoomObjDeltaWidth[objId],zoomObjStartHeight[objId],zoomObjDeltaHeight[objId],zoomObjSteps[objId],execbefore,execafter)
    zoomObjStartWidth[objId]=zoomObjStartWidth[objId]+zoomObjDeltaWidth[objId];
    zoomObjDeltaWidth[objId]=-(zoomObjDeltaWidth[objId]);
    zoomObjStartHeight[objId]=zoomObjStartHeight[objId]+zoomObjDeltaHeight[objId];
    zoomObjDeltaHeight[objId]=-(zoomObjDeltaHeight[objId]);
}

var fadeTimer  = new Array();
var fadeActive  = new Array();
var fadeObjStartValue = new Object();
var fadeObjDeltaValue = new Object();
var fadeObjSteps = new Object();
/**********************************************
prepare fading before calling the 'real' fade function fadeElement
parameters:
objid : id of obkject to zoom
stf: opacity value at beginning, 0=opaque, 100= transparent
deltaw: opacity delta? 
stp: steps - in how many steps is the fading effect to be realised? currently not functional as nr of steps is defined by performancechecker function
execWhenDone: javascript to execute after zooming is finished
note: if the function is called a second time for teh same object, it will fade automatically back to the initial value, the third call will refade automatically to the value that was defined in the first call, and so on.
this is done by saving the fade values in the fadeObj... objects.
**********************************************/
function startFade(objId,execWhenDone,stf,deltaf,stp) {
    if(!fadeObjStartValue[objId]) {
        fadeObjStartValue[objId]=stf;
        fadeObjDeltaValue[objId]=deltaf;
        fadeObjSteps[objId]=stp;
    }
    if (fadeSteps) fadeObjSteps[objId]=fadeSteps;
    fadeElement(objId,1,fadeObjStartValue[objId],fadeObjDeltaValue[objId],fadeObjSteps[objId],execWhenDone)
    fadeObjStartValue[objId]=fadeObjStartValue[objId]+fadeObjDeltaValue[objId];
    fadeObjDeltaValue[objId]=-(fadeObjDeltaValue[objId]);
}
/**********************************************
the 'real' zooming function
**********************************************/
function zoomElement(theID, zoomCurrent, zoomStartW, zoomChangeW, zoomStartH, zoomChangeH, zoomSteps, execBefore, execWhenDone) {
    if (zoomCurrent == 0) {
        if (execBefore != "") {
            eval(execBefore);
        }
    }
    // Test if we're done, or if we continue
    if (zoomCurrent == (zoomSteps + 1)) {
        zoomActive[theID] = false;
        clearInterval(zoomTimer[theID]);
        if (execWhenDone != "") {
            eval(execWhenDone);
        }
    } else {
        // Calculate this step's difference, and zoom it!
        moveW = getSquareDelta(zoomCurrent, zoomStartW, zoomChangeW, zoomSteps);
        moveH = getSquareDelta(zoomCurrent, zoomStartH, zoomChangeH, zoomSteps);
        document.getElementById(theID).style.width = moveW + 'px';
        document.getElementById(theID).style.height = moveH + 'px';
        zoomCurrent++;
        clearInterval(zoomTimer[theID]);
        zoomTimer[theID] = setInterval("zoomElement('"+theID+"', "+zoomCurrent+", "+zoomStartW+", "+zoomChangeW+", "+zoomStartH+", "+zoomChangeH+", "+zoomSteps+", '"+execBefore+"', '"+execWhenDone+"')", 5);
    }
}
/**********************************************
the 'real' fading function
**********************************************/
function fadeElement(theID, fadeCurrent, fadeStart, fadeChange,fadeSteps, execWhenDone) {
    // Test if we're done, or if we continue
    if (fadeCurrent == (fadeSteps + 1)) {
        fadeActive[theID] = false;
        clearInterval(fadeTimer[theID]);
        if (execWhenDone != "") {
            eval(execWhenDone);
        }
    } else {
        // Calculate this step's difference, and fade it!
        moveFade = getSquareDelta(fadeCurrent, fadeStart, fadeChange, fadeSteps);
        if (moveFade < 0) {
            setOpacity(moveFade, theID);
        } else {
            setOpacity(100 - (Math.abs(moveFade)), theID);
        }
        fadeCurrent++;
        clearInterval(fadeTimer[theID]);
        fadeTimer[theID] = setInterval("fadeElement('"+theID+"', "+fadeCurrent+", "+fadeStart+", "+fadeChange+", "+fadeSteps+", '"+execWhenDone+"')", 5);
    }
}
/**********************************************
subroutine called to set calculated opacity value
**********************************************/
function setOpacity(opacity, theID) {
    var object = document.getElementById(theID).style;
    // Firefox Bugfix
//    if (navigator.userAgent.indexOf("Firefox") != -1) {
//        if (opacity == 100) { opacity = 99.9999; }
//    }
    object.filter = "alpha(opacity=" + opacity + ")"; // IE/Win
    object.opacity = (opacity / 100);                 // Safari 1.2, Firefox+Mozilla
}
/**********************************************
subroutine called to calculate a nonlinear 'root' fading/zooming effect
**********************************************/
function getSquareDelta(t, b, c, d)
{
    if ((t/=d/2) < 1) return c/2*t*t*t + b;
    return c/2*((t-=2)*t*t + 2) + b;
}
/**********************************************
small function to switch between block and none display value
**********************************************/
function switchDisplay(objId) {
    if (getStyle(document.getElementById(objId),"display")!="none") {
        document.getElementById(objId).style.display = "none";
    } else {
        document.getElementById(objId).style.display = "block";
    }
}
/**********************************************
add or remove a class definition for an object defined by its id
**********************************************/
function toggleClass(objID,clsName) {
    var rgxp = new RegExp(clsName);
    if (document.getElementById(objID).className.search(rgxp)==-1) {
        document.getElementById(objID).className=document.getElementById(objID).className+" "+clsName;
    } else {
        document.getElementById(objID).className=document.getElementById(objID).className.replace(rgxp, "");;
    }
}
function unescapeHTML(str) {
    var div = document.createElement('div');
    div.innerHTML = str;
    return div.childNodes[0].nodeValue? div.childNodes[0].nodeValue : str;
}
ruleIndex=new Object();

/**********************************************
inject a style definition into a csss class
**********************************************/
function addCssRule(clsName,clsRule) {
    modCSS = document.styleSheets[0];
    ruleIndex[clsName]=modCSS.cssRules? modCSS.cssRules.length : modCSS.rules.length
    modCSS.addRule? modCSS.addRule(clsName,clsRule) : modCSS.insertRule(clsName+"{"+clsRule+"}", modCSS.cssRules.length);
}
/**********************************************
remove a style definition from a csss class, this works only if this definition has been injected by previous function
**********************************************/
function removeCssRule(clsName) {
    modCSS = document.styleSheets[0];
    ruleIndex[clsName] ? modCSS.deleteRule ? modCSS.deleteRule(ruleIndex[clsName]) : modCSS.removeRule(ruleIndex[clsName]) : "";
}

var pauseSecondStageToggle= new Object();
/**********************************************
this function is deprecated as of 2008-06-16
**********************************************/
function toggleSecondStage(objID,mode,delayed) {
    obj=document.getElementById(objID);
    if (obj.className!="secondstage "+mode) {
    if (delayed!=1) {
        pauseSecondStageToggle[objID]=0;
        window.setTimeout("toggleSecondStage('"+objID+"','"+mode+"',1);",250)
    }
    else
    if (pauseSecondStageToggle[objID]!=1) {
        obj.className="secondstage "+mode;
    }
    } else {
        pauseSecondStageToggle[objID]=1;
    }
}