/* ===========================================================================================
 VTour Core Services

 Author:  Selwyn Wan
 Company: EdgeState Services Inc.

 Copyright © 2008, 2009 EdgeState Services Inc.
 ===========================================================================================
*/

var kVTViewerVersion = "1.2.9";
var kVTCoreVersion = "1.2.9";

var kVTLoadTypeNone = 0;
var kVTLoadTypeLauncher = 1;
var kVTLoadTypeLocation = 2;
var kVTLoadTypeSearch = 3;
var kVTLoadTypeMap = 4;

var kVTSearchStartIndex = 2;
var kVTSearchEndIndex = 17;

var kVTSwingToTime = 500;

var kConCat_Hotel = 2;
var kConCat_Condo = 3;
var kConCat_Home = 4;
var kConCat_Restaurant = 5;
var kConCat_Transportation = 6;
var kConCat_Service = 7;
var kConCat_Activity = 8;
var kConCat_Special = 9;
var kConCat_Place = 10;
var kConCat_Bar = 11;
var kConCat_Shop = 12;
var kConCat_Rental = 13;
var kConCat_Suite = 14;
var kConCat_MeetingRoom = 15;
var kConCat_Amenity = 16;
var kConCat_Other = 17;

var gVTServerPath = "";
var gVTPlayerName = "VTour Player";

var gBrand = null;
var gBanner = null;
var gMap = null;
var gOverlay = null;
var gEventHandlersList = null;

var gLoadType = kVTLoadTypeNone;
var gStateChangeHandler = vtDefaultStateChangeHandler;

var gbDebug = false;
var gbDebugOutput = false;
var gDebugOutputCnt = 0;

var gCurInfoTemplate = null;
var gCurMapObj = null;

var gVTTarget_Pano = null;
var gVTTarget_Tween = null;
var gVTTarget_Location = null;
var gVTTarget_Status = null;
var gVTTarget_Tabs = null;
var gVTTarget_Brand = null;
var gVTTarget_Banner = null;
var gVTTarget_Map = null;
var gVTTarget_Dimout = null;
var gVTTarget_Overlay = null;
var gVTTarget_OverlayVideo = null;

var gVTContainerName_Pano = "panoContent";
var gVTContainerName_Tween = "tweenContent";
var gVTContainerName_Location = "locationText";
var gVTContainerName_Status = "statusText";
var gVTContainerName_Tabs = "summaryDiv";
var gVTContainerName_Brand = "brandImg";
var gVTContainerName_Banner = "bannerImg";
var gVTContainerName_Dimout = "dimoutArea";
var gVTContainerName_Overlay = "overlayImage";
var gVTContainerName_OverlayVideo = "overlayVideo";
var gVTContainerName_DebugOutput = "vtDebugOutput";

var gVTLoadPlaceUseEnterAngles = false;
var gVTLoadPlaceEnterPan = 0;
var gVTLoadPlaceEnterTilt = 0;
var gVTLoadPlaceEnterFOV = 0;

var gVTCurSearchIndex = 0;
var gVTSearchXML = "";

var gVTHistoryQueue = new Array();
var gVTCurHistoryIndex = -1;
var gVTIsHistoryNav = false;

var gVTCurPlaceID = "";
var gVTCurPlaceTitle = "";

var gVTOnline = false;
var gVTLanguage = "0";
var gVTRemoteURL = "";
var gVTProfile = "";

var gVTSessionID = "";

var gVTCurMarkerID = "";
var gVTMap = null;
var gMapXML = "";
var gVTNorthAngle = 0;
var gVTPanAnglePolingEnabled = false;
var gPanoXML = "";

var kEventsOffset_SummaryTextRow = 10000;
var kEventsOffset_ProximityTextRow = 11000;
var kEventsOffset_ProximityPOV = 12000;
var kEventsOffset_DetailsTextRow = 13000;
var kEventsOffset_Banner = 14000;
var kEventsOffset_OnLoad = 15000;

var gbVTIsMicrosoftBrowser = false;

var gbVTPanoReady = false;
var gVTSetPOVDuration = 0;

var gVTInitialTab = -1;
var gbVTPlayVideoAutoContinue = false;
var gVTPlayVideoContinueTo = "";

var gbVTUseAutoRotator = false;

var gbVTReplaceableBrand = true;

var gVTOnLoadCondListObj = null;

//=====================================================
// General Services
//=====================================================
var gLanguagePrefix;

function vtSetLanguagePrefix(inPrefix)
{
    gLanguagePrefix = inPrefix;
}

function vtGetLanguagePrefix()
{
    return gLanguagePrefix;
}

function vtQTToFPPPanAngle(inQTPanAngle)
{
    if (inQTPanAngle <= 180)
        return -inQTPanAngle;
    else
        return -((inQTPanAngle - 180) - 180);
}


//=====================================================
// Flash Services
//=====================================================
function vtCreateSWObject(inTargetURL, inTargetName, inWidth, inHeight, inVersion, inBackColor)
{
    return new SWFObject(inTargetURL, inTargetName, inWidth, inHeight, inVersion, inBackColor);
}

function vtGetSWFObject(inName)
{
    if (gbVTIsMicrosoftBrowser)
        return window[inName];
    else
        return document[inName];
}


//=====================================================
// History Services
//=====================================================
var vtcHistory = function(inPlaceID, inTitle, inPan, inTilt, inFOV)
{
    this.PlaceID = inPlaceID;
    this.Title = inTitle;
    this.Pan = inPan;
    this.Tilt = inTilt;
    this.FOV = inFOV;
}

function vtHistoryHasPrev()
{
    return (gVTCurHistoryIndex > 0);
}

function vtHistoryHasNext()
{
    return (gVTCurHistoryIndex < gVTHistoryQueue.length - 1);
}

function vtHistoryPush(inHistory)
{
    if (gVTCurHistoryIndex < gVTHistoryQueue.length - 1)
    {
        // We have to clear the subsequent items
        gVTHistoryQueue.length = gVTCurHistoryIndex + 1;
    }
    gVTHistoryQueue[gVTHistoryQueue.length] = inHistory;
    gVTCurHistoryIndex = gVTHistoryQueue.length - 1;
}

function vtHistoryGetByIndex(inIndex)
{
    var theHistory = null;
    if (inIndex >= 0 && inIndex < gVTHistoryQueue.length)
        theHistory = gVTHistoryQueue[inIndex];
    return theHistory;
}

function vtHistoryGetPrev()
{
    var theHistory = vtHistoryGetByIndex(gVTCurHistoryIndex - 1);
    if (theHistory != null)
        gVTCurHistoryIndex--;
    return theHistory;
}

function vtHistoryGetCur()
{
    return vtHistoryGetByIndex(gVTCurHistoryIndex);
}

function vtHistoryGetNext()
{
    var theHistory = vtHistoryGetByIndex(gVTCurHistoryIndex + 1);
    if (theHistory != null)
        gVTCurHistoryIndex++;
    return theHistory;
}

function vtHistoryGetFirst()
{
    var theHistory = vtHistoryGetByIndex(0);
    return theHistory;
}

function vtHistoryGoPrev()
{
    var theHistory = vtHistoryGetPrev();
    
    if (theHistory != null)
    {
        gVTIsHistoryNav = true;
        vtLoadPlace(theHistory.PlaceID, true);
    }
}

function vtHistoryGoNext()
{
    var theHistory = vtHistoryGetNext();
    
    if (theHistory != null)
    {
        gVTIsHistoryNav = true;
        vtLoadPlace(theHistory.PlaceID, true);
    }
}

function vtHistoryGoHome()
{
    var theHistory = vtHistoryGetFirst();
    
    if (theHistory != null)
    {
        gVTIsHistoryNav = true;
        vtLoadPlace(theHistory.PlaceID, true);
    }
}


//=====================================================
// RemoteXML Services
//=====================================================
var gHttpReqObj;

function vtGetHttpReqObj()
{
    var xmlHttp;
    
    try
    {  // Firefox, Opera 8.0+, Safari
        xmlHttp=new XMLHttpRequest();  
    }
    catch (e)
    {  // Internet Explorer  
        try
        {
            xmlHttp=new ActiveXObject("Msxml2.XMLHTTP");    
        }
        catch (e)
        {    
            try
            {
                xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");      
            }
            catch (e)
            {
                return null;      
            }    
        }  
    }  
    
    return xmlHttp;
}

function vtDefaultStateChangeHandler()
{
    alert("Remote HttpReqObj state change handler not set!");
}

function vtSetStateChangeHandler(inHandler)
{
    gStateChangeHandler = inHandler;
}

function vtIsHttpReqAvail()
{
    return (vtGetHttpReqObj() != null);
}

function vtGetRemoteHttpReqObj()
{
    return gHttpReqObj;
}

function vtGetRemoteXML(url)
{
    var bOK = false;
    if (!vtIsRemoteBusy())
    {
        var theReqObj = vtGetRemoteHttpReqObj();
        
        if (theReqObj == null)
        {
            gHttpReqObj = vtGetHttpReqObj();
            theReqObj = gHttpReqObj;
        }
        if (theReqObj != null)
        {
            try
            {
                theReqObj.onreadystatechange = gStateChangeHandler;
                theReqObj.open("GET", url, true);
                theReqObj.send(null);
                return true;
            }
            catch (e)
            {
                alert("Unable to access remote XML! " + e.message);
                return false;
            }
        }
    }
    
    return bOK;
}

function vtClearRemote()
{
    if (gHttpReqObj != null)
    {
        gHttpReqObj.abort();
    }
    gHttpReqObj = null;
}

function vtIsRemoteBusy()
{
    if (gHttpReqObj != null)
    {
        if (gHttpReqObj.readyState == 0 || gHttpReqObj.readyState == 4)
            return false;
        else
            return true;
    }
    else
        return false;
}

function vtLoadStateChangeHandler()
{
    var remoteHttpReqObj = vtGetRemoteHttpReqObj();
    
    if (remoteHttpReqObj != null)
    {
        if (remoteHttpReqObj.readyState == 4)
        {
            if (gbDebugOutput)
            {
                vtDebugOutput("vtLoadStateChangeHandler(State 4, Status=" + remoteHttpReqObj.status + ")");
            }
        
            var locationID;
            switch (gLoadType)
            {
                case kVTLoadTypeLauncher:
                    if (gbDebugOutput)
                        vtDebugOutput("vtLoadStateChangeHandler(kVTLoadTypeLauncher)");
        
                    if (remoteHttpReqObj.status == 200)
                    {
                        if ((locationID = vtParseLauncherXML(remoteHttpReqObj.responseXML)) != "")
                        {
                            // Now we can load the location
                            vtClearRemote();
                            gLoadType = kVTLoadTypeLocation;
                            vtLoadPlace(locationID, false);
                            if (window.console)
                                window.console.log("End of Load Launcher");
                        }
                    }
                    break;
                case kVTLoadTypeLocation:
                    if (gbDebugOutput)
                        vtDebugOutput("vtLoadStateChangeHandler(kVTLoadTypeLocation)");
                    if (remoteHttpReqObj.status == 200)
                    {
                        vtSpinnerHide();
                        
                        var responseXML = remoteHttpReqObj.responseXML;
                            
                        if (window.console)
                            window.console.log("Load Location Start:" + (responseXML != null) + " Status:" + remoteHttpReqObj.statusText);
                        if (window.console)
                            window.console.log(remoteHttpReqObj.responseText);
                        if (window.console)
                            window.console.log(remoteHttpReqObj.statusText);
                            
                        if (responseXML == null && remoteHttpReqObj.responseText != "")
                        {
                            try //Internet Explorer
                            {
                                responseXML = new ActiveXObject("Microsoft.XMLDOM");
                                responseXML.async = false;
                                responseXML.loadXML(remoteHttpReqObj.responseText);
                            }
                            catch(e)
                            {
                                try //Firefox, Mozilla, Opera, etc.
                                {
                                    var parser = new DOMParser();
                                    responseXML = parser.parseFromString(remoteHttpReqObj.responseText, "text/xml");
                                    responseXML.async = false;
                                    if (window.console)
                                        window.console.log("Create new DOM... " + (responseXML != null));
                                }
                                catch(e)
                                {
                                    alert(e.message);
                                    return;
                                }
                            }
                        }    
                            
                        if ((gCurInfoTemplate = vtGetInfoTemplateFromDocument(responseXML)) != null)
                        {
                            if (window.console)
                                window.console.log("Got Info Template");
                            vtClearEventHandlers();
                            gSWPano = vtLoadPano(gCurInfoTemplate.PanoObj);
                            if (gCurInfoTemplate.ImageListObj != null && gCurInfoTemplate.ImageListObj.ImageList != null)
                                vtLoadBrand(gCurInfoTemplate.ImageListObj.ImageList[0]);
                            if (gCurInfoTemplate.BannerObj != null)
                                vtLoadBanner(gCurInfoTemplate.BannerObj);
                            if (gCurInfoTemplate.TabListObj != null)
                                vtLoadSummaryTab(gCurInfoTemplate.TabListObj, gCurInfoTemplate.PanoObj);
                            vtNavInitialize(false);
                            
                            if (gVTOnLoadCondListObj != null)
                            {
                                vtAddEventHandler(kEventsOffset_OnLoad, gVTOnLoadCondListObj);
                                gVTOnLoadCondListObj = null;
                            }
                            
                            vtHandleEvent(kEventsOffset_OnLoad, kVTCondActionType_Loaded);
                            
                            if (gVTSearchXML == "")
                            {
                                gLoadType = kVTLoadTypeSearch;
                                vtClearRemote();
                                gVTCurSearchIndex = kVTSearchStartIndex;
                                
                                var path;
                                
                                if (gVTOnline)
                                    path = gVTServerPath + "?s" + gVTCurSearchIndex + "=1&prof=" + gVTProfile;
                                else
                                    path = vtGetLanguagePrefix() + "/xml/s" + gVTCurSearchIndex + ".xml";
                                    
                                vtGetRemoteXML(path);
                            }
                            else
                                vtApplySearchItems();
                                
                            if (gVTInitialTab >= 0)
                            {
                                vtNavSelectTab(gVTInitialTab)
                                gVTInitialTab = -1;
                            }
                        }
                    }
                    break;
                 case kVTLoadTypeSearch:
                    if (gbDebugOutput)
                        vtDebugOutput("vtLoadStateChangeHandler(kVTLoadTypeSearch, gVTCurSearchIndex=" + gVTCurSearchIndex + ")");
                    if (remoteHttpReqObj.status == 200)
                    {
                        var responseXML = remoteHttpReqObj.responseXML;
                            
                        if (responseXML == null && remoteHttpReqObj.responseText != "")
                        {
                            try //Internet Explorer
                            {
                                responseXML = new ActiveXObject("Microsoft.XMLDOM");
                                responseXML.async = false;
                                responseXML.loadXML(remoteHttpReqObj.responseText);
                            }
                            catch(e)
                            {
                                try //Firefox, Mozilla, Opera, etc.
                                {
                                    var parser = new DOMParser();
                                    responseXML = parser.parseFromString(remoteHttpReqObj.responseText, "text/xml");
                                    responseXML.async = false;
                                    if (window.console)
                                        window.console.log("Create new DOM... " + (responseXML != null));
                                }
                                catch(e)
                                {
                                    alert(e.message);
                                    return;
                                }
                            }
                        }    
                            
                        vtSearchDocAppend(responseXML);
                    }
                    if (gVTCurSearchIndex < kVTSearchEndIndex)
                    {
                        vtClearRemote();
                        gLoadType = kVTLoadTypeSearch;
                        gVTCurSearchIndex++;
                        
                        var path;
                        
                        if (gVTOnline)
                            path = gVTServerPath + "?s" + gVTCurSearchIndex + "=1&prof=" + gVTProfile;
                        else
                            path = vtGetLanguagePrefix() + "/xml/s" + gVTCurSearchIndex + ".xml";
                        
                        vtGetRemoteXML(path);
                    }
                    else
                    {
                        // Finished gathering the search XML data
                        vtApplySearchItems();
                        vtClearRemote();
                    }
                    break;
                 case kVTLoadTypeMap:
                    if (gbDebugOutput)
                        vtDebugOutput("vtLoadStateChangeHandler(kVTLoadTypeMap)");
                    if (remoteHttpReqObj.status == 200)
                    {
                        var responseXML = remoteHttpReqObj.responseXML;
                        
                        if (window.console)
                            window.console.log("Load Map Start:" + (responseXML != null) + " Status:" + remoteHttpReqObj.statusText);
                        if (window.console)
                            window.console.log(remoteHttpReqObj.responseText);
                        if (window.console)
                            window.console.log(remoteHttpReqObj.statusText);
                            
                        if (responseXML == null && remoteHttpReqObj.responseText != "")
                        {
                            try //Internet Explorer
                            {
                                responseXML = new ActiveXObject("Microsoft.XMLDOM");
                                responseXML.async = false;
                                responseXML.loadXML(remoteHttpReqObj.responseText);
                            }
                            catch(e)
                            {
                                try //Firefox, Mozilla, Opera, etc.
                                {
                                    var parser = new DOMParser();
                                    responseXML = parser.parseFromString(remoteHttpReqObj.responseText, "text/xml");
                                    responseXML.async = false;
                                    if (window.console)
                                        window.console.log("Create new DOM... " + (responseXML != null));
                                }
                                catch(e)
                                {
                                    alert(e.message);
                                    return;
                                }
                            }
                        }    
                            
                        if ((gCurMapObj = vtGetMapFromDocument(responseXML)) != null)
                        {
                            if (window.console)
                                window.console.log("Got MapObj");
                            vtClearMapEventHandlers();
                            vtLoadMapTab(gCurMapObj);
                        }
                    }
                    break;
            }
        }
    }
}

function vtSearchDocAppend(inSearchXML)
{
    try
    {
        var resultTag = vtGetSubTagTag(inSearchXML, "result");
        if (resultTag != null)
        {
            var theItems = resultTag.getElementsByTagName("item")
            if (theItems != null && theItems.length > 0)
            {
                var theItem;
                var theCatID, theTitle, theObjID;
                
                for (var idx = 0; idx < theItems.length; idx++)
                {
                    theCatID = vtGetSubTagValue(theItems[idx], "catID");
                    theTitle = vtGetSubTagValue(theItems[idx], "title");
                    theObjID = vtGetSubTagValue(theItems[idx], "objID");
                    gVTSearchXML += "<item><catID>" + theCatID + "</catID><title>" + theTitle + "</title><objID>" + theObjID + "</objID></item>";
                }
            }
        }
    }
    catch(e)
    {
        alert(e.message);
    }
}

function vtGetCategoryName(inCatID)
{
    switch (inCatID)
    {
        case 1: return "None"; break;
        case 2: return "Hotels"; break;
        case 3: return "Condos"; break;
        case 4: return "Homes"; break;
        case 5: return "Restaurants"; break;
        case 6: return "Transportation"; break;
        case 7: return "Services"; break;
        case 8: return "Activities"; break;
        case 9: return "Special"; break;
        case 10: return "Places"; break;
        case 11: return "Bars"; break;
        case 12: return "Shops"; break;
        case 13: return "Rental"; break;
        case 14: return "Suites"; break;
        case 15: return "Meeting Rooms"; break;
        case 16: return "Amenities"; break;
        case 17: return "Other"; break;
    }
}

function vtApplySearchItems()
{
    var searchDoc = null;
    
    try //Internet Explorer
    {
        searchDoc=new ActiveXObject("Microsoft.XMLDOM");
        searchDoc.async=false;
        searchDoc.loadXML("<search>" + gVTSearchXML + "</search>");
    }
    catch(e)
    {
        try //Firefox, Mozilla, Opera, etc.
        {
            var parser = new DOMParser();
            searchDoc = parser.parseFromString("<search>" + gVTSearchXML + "</search>", "text/xml");
            searchDoc.async=false;
        }
        catch(e)
        {
            alert(e.message);
            return;
        }
    }
    
    var searchTags = searchDoc.getElementsByTagName("search");
    if (searchTags != null && searchTags.length > 0)
    {
        var searchTag = searchTags[0];
        
        var searchDiv = vtFindTabPane(kVTTabTypeSearch);
        
        if (searchDiv != null)
        {
            var theHTML = "";
            var catID;
            var title;
            var objID;
            var curCatID = 0;
            var itemTags;
            itemTags = searchTag.getElementsByTagName("item");
            if (itemTags != null && itemTags.length > 0)
            {
                for (var idx = 0; idx < itemTags.length; idx++)
                {
                    catID = vtGetSubTagValue(itemTags[idx], "catID");
                    title = vtGetSubTagValue(itemTags[idx], "title");
                    objID = vtGetSubTagValue(itemTags[idx], "objID");
                    if (curCatID != parseInt(catID))
                    {
                        curCatID = parseInt(catID);
                        theHTML += "<div class='listTop'>" + vtGetCategoryName(curCatID) + "</div>";
                    }
                    theHTML += "<div class='listItem' onclick='vtGoToPlace(\"" + objID + "\")'><div class='left'>" + title + "</div><div class='right'>&nbsp;</div><br class='clear'/></div>";
                }
            }
            searchDiv.innerHTML = "<div id='tabcJump'>" + theHTML + "</div>";
        }
    }
}


//=====================================================
// Pano Services
//=====================================================
var gFlashPano;
var gPanoName;
var gFlashTween;
var gTweenName;
var gFlashTweenObj = null;
var gFlashVideoPlayerObj = null;

function vtGetPanoObject()
{
    return gFlashPano;
}

function vtCreatePanoObject(inTargetURL, inTargetName, inWidth, inHeight, inVersion, inBackColor)
{
    gFlashPano = new SWFObject(inTargetURL, inTargetName, inWidth, inHeight, inVersion, inBackColor);
    gPanoName = inTargetName;
    return gFlashPano;
}

function vtCreateTweenObject(inTargetURL, inTargetName, inWidth, inHeight, inVersion, inBackColor)
{
    gFlashTween = new SWFObject(inTargetURL, inTargetName, inWidth, inHeight, inVersion, inBackColor);
    gTweenName = inTargetName;
    return gFlashTween;
}

function vtGetPanAngle()
{
    try
    {
        return document.pano.panoCtrlPanoGet("pano.pan");
    }
    catch (e)
    {
    }
}

function vtSetPanAngleTo(inAngle, inTime)
{
    try
    {
        document.pano.panoCtrlPanoExecute("pano.pan="+inAngle+","+inTime);
    }
    catch (e)
    {
    }
}

function vtSetPanAngleBy(inAngle, inTime)
{
    try
    {
        document.pano.panoCtrlPanoExecute("pano.pan+="+inAngle+","+inTime);
    }
    catch (e)
    {
    }
}

function vtGetTiltAngle()
{
    try
    {
        return document.pano.panoCtrlPanoGet("pano.tilt");
    }
    catch (e)
    {
    }
}

function vtSetTiltAngleTo(inAngle, inTime)
{
    try
    {
        document.pano.panoCtrlPanoExecute("pano.tilt="+inAngle+","+inTime);
    }
    catch (e)
    {
    }
}

function vtSetTiltAngleBy(inAngle, inTime)
{
    try
    {
        document.pano.panoCtrlPanoExecute("pano.tilt+="+inAngle+","+inTime);
    }
    catch (e)
    {
    }
}

function vtGetFOVAngle()
{
    try
    {
        return document.pano.panoCtrlPanoGet("pano.vfov");
    }
    catch (e)
    {
    }
}

function vtSetFOVAngleTo(inAngle, inTime)
{
    try
    {
        document.pano.panoCtrlPanoExecute("pano.hfov="+inAngle+","+inTime);
        document.pano.panoCtrlPanoExecute("pano.vfov="+inAngle+","+inTime);
    }
    catch (e)
    {
    }
}

function vtSetFOVAngleBy(inAngle, inTime)
{
    try
    {
        document.pano.panoCtrlPanoExecute("pano.hfov+="+inAngle+","+inTime);
        document.pano.panoCtrlPanoExecute("pano.vfov+="+inAngle+","+inTime);
    }
    catch (e)
    {
    }
}

function vtGetPanAngleDelta(inStartAngle, inDestAngle)
{
    var normStartAngle = inStartAngle;
    var normDestAngle = inDestAngle
    if (normStartAngle < 0)
        normStartAngle = 180 + (180 + normStartAngle);
    if (normDestAngle < 0)
        normDestAngle = 180 + (180 + normDestAngle);

    var deltaAngle = normDestAngle - normStartAngle;
    
    if (deltaAngle >= 0)
    {
        if (deltaAngle > 180)
            return deltaAngle - 360;
        else
            return deltaAngle;
    }
    else
    {
        if (deltaAngle < -180)
            return deltaAngle + 360;
        else
            return deltaAngle;
    }
}

//=====================================================
// Object Loader Services
//=====================================================
function vtGetRDTagInDocument(inDocument, inParamArray)
{
    var theRDTag = null;
    
    if (window.console)
        window.console.log("GetRDTagInDocument start" + (inDocument != null));
    if (inDocument != null)
    {
        if (window.console)
            window.console.log("GetRDTagInDocument start");
        var rootTags = inDocument.getElementsByTagName("root");
        if (rootTags != null && rootTags.length > 0)
        {
            if (window.console)
                window.console.log("Found Root");
            var rootTag = rootTags[0];
            var theRSTags = rootTag.getElementsByTagName("rs");
            if (theRSTags != null && theRSTags.length > 0)
            {
                if (window.console)
                    window.console.log("Found rs");
                var theRSTag = theRSTags[0];
                var theID = vtGetSubTagValue(theRSTag, "id");
                if (theID != null)
                    inParamArray[inParamArray.length] = theID;
                var theRDTags = theRSTag.getElementsByTagName("rd");
                if (theRDTags != null && theRDTags.length > 0)
                {
                    if (window.console)
                        window.console.log("Found rd");
                    theRDTag = theRDTags[0];
                }
            }
            var theSI = vtGetSubTagValue(rootTag, "si");
            if (theSI != null)
            {
                if (window.console)
                    window.console.log("Found si");
                inParamArray[inParamArray.length] = theSI;
            }
        }
    }
    
    return theRDTag;
}

function vtGetSubTagValue(inTag, inSubTagName)
{
    var theTags = inTag.getElementsByTagName(inSubTagName);
    if (theTags != null && theTags.length > 0)
    {
        if (theTags[0].childNodes.length > 0)
            return theTags[0].childNodes[0].nodeValue;
        else
            return "";
    }
    else
        return null;
}

function vtGetSubTagTag(inTag, inSubTagName)
{
    var theTags = inTag.getElementsByTagName(inSubTagName);
    if (theTags != null && theTags.length > 0)
        return theTags[0];
    else
        return null;
}

function vtFindTabPane(inTabPaneType)
{
    var thePane = null;
    if (gVTTarget_Tabs != null)
    {
        if (gVTTarget_Tabs.childNodes.length > 0)
        {
            for (var idx = 0; idx < gVTTarget_Tabs.childNodes.length; idx++)
            {
                if (gVTTarget_Tabs.childNodes[idx].id == ("content" + inTabPaneType))
                {
                    thePane = gVTTarget_Tabs.childNodes[idx];
                    break;
                }
            }
        }
    }
    return thePane;
}

var gEnterPan = 0;
var gEnterTilt = 0;
var gEnterFOV = 0;
var gUseFadeIn = false;

function vtLoadPano(inPanoObj)
{
    if (gbDebugOutput)
        vtDebugOutput("vtLoadPano");
        
    if (gVTTarget_Pano != null && inPanoObj != null && inPanoObj.Media != null)
    {
        var locName = inPanoObj.Media.URL;
        var fileName = locName.substring(locName.lastIndexOf("/") + 1, locName.length);
        var filePrefix = fileName.substring(0, fileName.lastIndexOf("."));
        
        var thePan, theTilt, theFOV;
        var theHSXml = "";
        
        gVTCurMarkerID = inPanoObj.RefID;
        gVTNorthAngle = inPanoObj.NorthAngle;
        
        if (inPanoObj.InitialAngles != null)
        {
            thePan = inPanoObj.InitialAngles.Pan;
            theTilt = inPanoObj.InitialAngles.Tilt;
            theFOV = inPanoObj.InitialAngles.FOV;
            
            
            var theHotspot;
            var theEnterAngles = null;
            var theExitAngles = null;
            
            if (inPanoObj.HotspotListObj != null)
            {
            
                for (var idx = 0; idx < inPanoObj.HotspotListObj.length(); idx++)
                {
                    theHotspot = inPanoObj.HotspotListObj.GetByIndex(idx);
                    
                    // Find the enter angles
                    if (theHotspot.CoordVRListObj != null)
                    {
                        var theCoord;
                        
                        for (var idx1 = 0; idx1 < theHotspot.CoordVRListObj.length(); idx1++)
                        {
                            theCoord = theHotspot.CoordVRListObj.GetByIndex(idx1);
                            if (theCoord.Type == kVTCoordVRType_Enter)
                                theEnterAngles = theCoord;
                            else if (theCoord.Type == kVTCoordVRType_Exit)
                                theExitAngles = theCoord;
                        }
                    }
                    
                    if (theEnterAngles != null && theHotspot.CondListObj != null)
                    {
                        var theCondAction;
                        for (var idx1 = 0; idx1 < theHotspot.CondListObj.length(); idx1++)
                        {
                            theCondAction = theHotspot.CondListObj.GetByIndex(idx1);
                            if (theCondAction.ActionListObj != null)
                            {
                                var theAction;
                                for (var idx2 = 0; idx2 < theCondAction.ActionListObj.length(); idx2++)
                                {
                                    theAction = theCondAction.ActionListObj.GetByIndex(idx2);
                                    if (theAction.Type == kVTActionType_LoadPlace || theAction.Type == kVTActionType_LoadPlaceWithTransition)
                                    {
                                        if (theAction.ParamListObj != null)
                                        {
                                            theAction.ParamListObj.Add(theEnterAngles);
                                            if (theExitAngles != null)
                                                theAction.ParamListObj.Add(theExitAngles);
                                            if (theAction.Type == kVTActionType_LoadPlaceWithTransition)
                                                theAction.ParamListObj.Add(theHotspot.Media);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    
                    theHSXml += vtMakeFPPHotspotXML(theHotspot);
                    vtAddEventHandler(theHotspot.HotspotID, theHotspot.CondListObj);
                }
            }
        }
        
        if (gVTLoadPlaceUseEnterAngles)
        {
            gVTLoadPlaceUseEnterAngles = false;
            thePan = gVTLoadPlaceEnterPan;
            theTilt = gVTLoadPlaceEnterTilt;
            theFOV = gVTLoadPlaceEnterFOV;
        }
        
        if (gVTIsHistoryNav)
        {
            var theHistory = vtHistoryGetCur();
            
            if (theHistory != null)
            {
                thePan = -theHistory.Pan;
                theTilt = theHistory.Tilt;
                theFOV = theHistory.FOV;
            }
        }

        //var theSWPano = vtCreatePanoObject("iv-tg_panoplayer.swf", "pano", "480", "270", "9", "#282828"); 
        
        gEnterPan = vtQTToFPPPanAngle(thePan);
        gEnterTilt = theTilt;
        gEnterFOV = theFOV;
        //gPanoXML = vtMakeFlashPanoXML(gVTRemoteURL + gLanguagePrefix + "/media/" + filePrefix, gEnterPan, gEnterTilt, gEnterFOV, theHSXml);
        if (gVTOnline)
            gPanoXML = vtMakeFlashPanoXML(gVTRemoteURL + gLanguagePrefix + "/media/" + filePrefix, vtQTToFPPPanAngle(thePan), theTilt, theFOV, theHSXml);
        else
            gPanoXML = vtMakeFlashPanoXML(gLanguagePrefix + "/media/" + filePrefix, vtQTToFPPPanAngle(thePan), theTilt, theFOV, theHSXml);
        
        //theSWPano.addVariable("xml_text", vtMakeFlashPanoXML(gVTRemoteURL + gLanguagePrefix + "/media/" + filePrefix, vtQTToFPPPanAngle(thePan), theTilt, theFOV, theHSXml));
        //theSWPano.addVariable("xml_file", gLanguagePrefix + "/xml/flash_" + filePrefix + ".xml");
        //theSWPano.addVariable("redirect", window.location);
        //theSWPano.addParam("allowFullScreen","true");
        //theSWPano.addParam("allowScriptAccess","sameDomain");
        //theSWPano.addParam("wmode", "window");
        //theSWPano.write(gVTTarget_Pano);
        
        gbVTPanoReady = false;
        setTimeout(vtDelayedLoadPanoXML, 500);
        //tgGetSWFObject("pano").panoLoad(gPanoXML);
        
        if (!gVTIsHistoryNav)
        {
            var theHistory = new vtcHistory(gVTCurPlaceID, inPanoObj.Title, thePan, theTilt, theFOV);
            vtHistoryPush(theHistory);
        }
        gVTIsHistoryNav = false;
        gVTCurPlaceTitle = inPanoObj.Title;
        
        if (gVTTarget_Location != null)
            gVTTarget_Location.innerHTML = inPanoObj.Title;
            
        //return theSWPano;
        return null;
    }
    else
    {
        gVTTarget_Status.innerHTML = "<b>Panorama failed to load!</b>";
        return null;
    }
}

function vtDelayedLoadPanoXML()
{
    if (gbDebugOutput)
        vtDebugOutput("vtDelayedLoadPanoXML");
        
    var fadeCmd = "none";
    
    if (gUseFadeIn)
        fadeCmd = "fade";
    
    try
    {
        vtGetSWFObject("pano").panoLoad(gPanoXML, fadeCmd);
    }
    catch(ex)
    {
        document.pano.panoLoad(gPanoXML, fadeCmd);
    }
    gPanoXML = "";
    if (!gbVTTweenPlaying)
        vtSpinnerShow();
}

function vtLoadTween(inTweenMediaPath)
{
    if (gbDebugOutput)
        vtDebugOutput("vtLoadTween(\"" + inTweenMediaPath + "\")");
        
    if (inTweenMediaPath != null)
    {
        var fileName = inTweenMediaPath.substring(0, inTweenMediaPath.lastIndexOf("."));
        
        gTweenPlaying = false;
        gbPlayVideo = false;
        
        if (gFlashTweenObj != null)
        {
            var targetPath = "";
            if (gVTOnline)
                targetPath = gVTRemoteURL + fileName + ".flv";
            else
                targetPath = fileName + ".flv";
            if (gLastTweenFLVPath == targetPath)
            {
                gFlashTweenObj.flvControl('rewind');
                gFlashTweenObj.showLayer('flv');
                gFlashTweenObj.flvControl('play');
                gbVTTweenPlaying = true;
                vtSpinnerHide();
                if (vtBrowserSupportOverlappedSWF())
                {
                    vtLoadPlace(gVTLoadPlaceWithTweenPlacePath, false);
                    gVTLoadPlaceWithTweenPlacePath = "";
                }
            }
            else
            {
                gLastTweenFLVPath = targetPath;
                if (gVTOnline)
                    gFlashTweenObj.flvLoad(targetPath);
                else
                {
                    if (targetPath.indexOf(":") >= 0)
                        gFlashVideoPlayerObj.flvLoad(targetPath);
                    else
                        gFlashTweenObj.flvLoad("../" + targetPath);
                }
            }
        }
       
        return null;
    }
    else
    {
        return null;
    }
}

function vtLoadBrand(inMedia)
{
    if (gbDebugOutput)
        vtDebugOutput("vtLoadBrand");
        
    if (gbVTReplaceableBrand)
    {
        if (gVTTarget_Brand != null && inMedia != null)
        {
            gBrand = vtCreateSWObject(gVTRemoteURL + inMedia.URL, "brand", "200", "70", "9", "#000000"); 
            gBrand.addParam("wmode", "transparent");
            gBrand.write(gVTTarget_Brand);
        }
        else
        {
            if (gVTTarget_Brand != null)
                gVTTarget_Brand.innerHTML = "<b>Brand failed to load!</b>";
        }
    }
}

function vtLoadBanner(inBanner)
{
    if (gbDebugOutput)
        vtDebugOutput("vtLoadBanner");
        
    if (gVTTarget_Banner != null && inBanner != null && inBanner.Media != null)
    {
        var fileSuffix = inBanner.Media.URL.substr(inBanner.Media.URL.lastIndexOf(".") + 1, inBanner.Media.URL.length - inBanner.Media.URL.lastIndexOf(".")).toLowerCase();
        
        if (fileSuffix == "swf")
        {
            gBanner = vtCreateSWObject(gVTRemoteURL + inBanner.Media.URL, "banner", "270", "70", "9", "#000000"); 
            gBanner.addParam("wmode", "transparent");
            gBanner.write(gVTTarget_Banner);
        }
        else
        {
            gVTTarget_Banner.innerHTML = "<img src=\"" + gVTRemoteURL + inBanner.Media.URL + "\" width=270 height=70>";
        }
        
        if (inBanner.CondListObj != null)
        {
            vtAddEventHandler(kEventsOffset_Banner, inBanner.CondListObj);
            var contextText = "";
            
            contextText = "<div id='bannerWrapper'" + vtGetHTMLEventHandlerScript(kEventsOffset_Banner) + ">" + gVTTarget_Banner.innerHTML + "</div>";
            gVTTarget_Banner.innerHTML = contextText;
        }
    }
    else
    {
        if (gVTTarget_Banner != null)
            gVTTarget_Banner.innerHTML = "<b>Banner failed to load!</b>";
    }
}

function vtLoadMapDiv(inMapDiv, inMap, inMapXML)
{
    if (gbDebugOutput && gVTTarget_DebugOutput != null)
    {
        gVTTarget_DebugOutput.innerHTML += (++gDebugOutputCnt) + ": vtLoadMapDiv<br>";
        gVTTarget_DebugOutput.scrollTop = gVTTarget_DebugOutput.scrollHeight;
    }
        
    var theHTML = "";
    
    if (inMap != null)
    {
        gMap = vtCreateSWObject("files/iv-tg_map.swf", "flashmap", "263", "264", "9", "#FFFFFF"); 
        gMap.addParam("allowScriptAccess", "always");
        gMap.addParam("allowFullScreen", "true");
        gMap.addParam("quality", "high");
        gMap.addParam("wmode", "opaque");
        gMap.write(inMapDiv);
        try
        {
             if(gbVTIsMicrosoftBrowser){
                  gVTMap = window["flashmap"];
             }else{
                  gVTMap = document["flashmap"];
             }
             if (gVTMap != null)
             {
                gMapXML = inMapXML;
                setTimeout(vtDelayedLoadMapXML, 2000);
             }
        }
        catch (ex)
        {
        }
    }
    return theHTML;
}

function vtDelayedLoadMapXML()
{
    if (gbDebugOutput)
        vtDebugOutput("vtDelayedLoadMapXML");
        
    try
    {
        vtGetSWFObject("flashmap").loadMap(gMapXML);
        vtGetSWFObject("flashmap").setCurrentMarker(gVTCurMarkerID);
        gVTPanAnglePolingEnabled = true;
        setTimeout(vtPolePanAngle, 500);
    }
    catch (ex)
    {
    }
}

function viewerLoaded()
{
    if (gbDebugOutput)
        vtDebugOutput("viewerLoaded");
        
    vtDelayedLoadMapXML()
}

function vtPolePanAngle()
{
    try
    {   
        var panoAngle = vtGetPanAngle();
        var adjustedAngle = parseInt(gVTNorthAngle) + parseInt(panoAngle);
        vtGetSWFObject("flashmap").rotateCurrentMarker(adjustedAngle);
    }
    catch(ex)
    {
    }
    if (gVTPanAnglePolingEnabled)
        setTimeout(vtPolePanAngle, 500)
}

function vtGetHTMLEventHandlerScript(inEventID)
{
    var scriptText = "";
    
    scriptText += " onclick='vtHandleEvent(" + inEventID + ", " + kVTCondActionType_MouseClick + ");'";
    scriptText += " onmouseover='vtHandleEvent(" + inEventID + ", " + kVTCondActionType_MouseEnter + ");'";
    scriptText += " onmouseout='vtHandleEvent(" + inEventID + ", " + kVTCondActionType_MouseExit + ");'";
    scriptText += " onmousedown='vtHandleEvent(" + inEventID + ", " + kVTCondActionType_MouseDown + ");'";
    scriptText += " onmouseup='vtHandleEvent(" + inEventID + ", " + kVTCondActionType_MouseUp + ");'";
    scriptText += " onmousemove='vtHandleEvent(" + inEventID + ", " + kVTCondActionType_MouseMoved + ");'";
    
    return scriptText;
}

function vtLoadSummaryTab(inTabListObj, inPanoObj)
{
    if (gVTTarget_Tabs != null && inTabListObj != null)
    {
        var fullContentText = "";
        var contentText;
        var theTab = null;
        var theMapTab = null;
        var theMapXML = "";
        
        for (var idx = 0; idx < inTabListObj.TabList.length; idx++)
        {
            theTab = inTabListObj.TabList[idx];
            
            contentText = "<div id='content" + theTab.Type + "' style='display: none'>";
            switch (parseInt(theTab.Type))
            {
                case kVTTabTypeSummary:
                    {
                        contentText += "<div id='tabcJump'>";
                        
                        if (theTab.Header != null)
                        {
                            contentText += "<div class='listHeader'><div class='left'>" + theTab.Header.Name + "</div><div class='right'>" + theTab.Header.Value + "</div><br class='clear'/></div>";
                        }
                        
                        if (theTab.RowListObj != null)
                        {
                            var curType = "";
                            var theRow = null;
                            
                            for (var idx1 = 0; idx1 < theTab.RowListObj.RowList.length; idx1++)
                            {
                                theRow = theTab.RowListObj.RowList[idx1];
                                if (curType != theRow.Type)
                                {
                                    contentText += "<div class='listTop'>" + theRow.Type + "</div>";
                                    curType = theRow.Type;
                                }
                                vtAddEventHandler(theRow.ID + kEventsOffset_SummaryTextRow, theRow.CondListObj);
                                contentText += "<div class='listItem'" + vtGetHTMLEventHandlerScript(theRow.ID + kEventsOffset_SummaryTextRow) + "><div class='left'>" + theRow.Header.Name + "</div><div class='right'>" + theRow.Header.Value + "</div><br class='clear'/></div>";
                            }
                        }
                        
                        contentText += "</div>";
                        break;
                    }
                    break;
                    
                case kVTTabTypeProximity:
                    {
                        contentText += "<div id='tabcShowMe'>";
                        
                        if (theTab.Header != null)
                        {
                            contentText += "<div class='listHeader'><div class='left'>" + theTab.Header.Name + "</div><div class='right'>" + theTab.Header.Value + "</div><br class='clear'/></div>";
                        }
                        
                        if (theTab.RowListObj != null)
                        {
                            var curType = "";
                            var theRow = null;
                            
                            for (var idx1 = 0; idx1 < theTab.RowListObj.RowList.length; idx1++)
                            {
                                theRow = theTab.RowListObj.RowList[idx1];
                                if (parseInt(theRow.ID) != 0)
                                {
                                    vtAddEventHandler(theRow.ID + kEventsOffset_ProximityTextRow, theRow.CondListObj);
                                    contentText += "<div class='listItem'" + vtGetHTMLEventHandlerScript(theRow.ID + kEventsOffset_ProximityTextRow) + ">";
                                    if (theRow.Header != null)
                                        contentText += "<div class='left'>" + theRow.Header.Name + "</div><div class='right'>" + theRow.Header.Value + "</div>";
                                    contextText += "<br class='clear'/></div>";
                                }
                                else
                                {
                                    // Special case where the Row ID is 0: Inject the Hotspot events here
                                    if (inPanoObj != null && inPanoObj.HotspotListObj != null)
                                    {
                                        if (inPanoObj.HotspotListObj.HotspotList.length > 0)
                                        {
                                            var theHotspotList = inPanoObj.HotspotListObj.HotspotList;
                                            var theHotspot;
                                            for (var idx2 = 0; idx2 < theHotspotList.length; idx2++)
                                            {
                                                theHotspot = theHotspotList[idx2];
                                                
                                                var thePan, theTilt, theFOV;
                                                
                                                // Create a cond-list for the hotspot
                                                if (theHotspot.CoordVRListObj != null)
                                                {
                                                    var theCoord;
                                                    for (var idx3 = 0; idx3 < theHotspot.CoordVRListObj.CoordVRList.length; idx3++)
                                                    {
                                                        theCoord = theHotspot.CoordVRListObj.CoordVRList[idx3];
                                                        if (parseInt(theCoord.Type) == kVTCoordVRType_Exit)
                                                        {
                                                            thePan = theCoord.Pan;
                                                            theTilt = theCoord.Tilt;
                                                            theFOV = theCoord.FOV;
                                                            break;
                                                        }
                                                    }
                                                }
                                                
                                                if (thePan != null)
                                                {
                                                    var theParamList = new vtcParamList();
                                                    
                                                    theParamList.ParamList[theParamList.ParamList.length] = thePan;
                                                    theParamList.ParamList[theParamList.ParamList.length] = theTilt;
                                                    theParamList.ParamList[theParamList.ParamList.length] = theFOV;
                                                    
                                                    var theAction = new vtcAction();
                                                    
                                                    theAction.Type = kVTActionType_ShowPOV;
                                                    theAction.ParamListObj = theParamList;
                                                    
                                                    var theActionList = new vtcActionList();
                                                    
                                                    theActionList.ActionList[theActionList.ActionList.length] = theAction;
                                                    
                                                    var theCondAction = new vtcCondAction();
                                                    
                                                    theCondAction.Type = kVTCondActionType_MouseClick;
                                                    theCondAction.ActionListObj = theActionList;
                                                    
                                                    var theCondList = new vtcCondList();
                                                    
                                                    theCondList.CondList[theCondList.CondList.length] = theCondAction;
                                                    
                                                    theParamList = new vtcParamList();
                                                    
                                                    theParamList.ParamList[theParamList.ParamList.length] = theHotspot.Title;
                                                    
                                                    theAction = new vtcAction();
                                                    
                                                    theAction.Type = kVTActionType_ShowText;
                                                    theAction.ParamListObj = theParamList;
                                                    
                                                    theActionList = new vtcActionList();
                                                    
                                                    theActionList.ActionList[theActionList.ActionList.length] = theAction;
                                                    
                                                    theCondAction = new vtcCondAction();
                                                    
                                                    theCondAction.Type = kVTCondActionType_MouseEnter;
                                                    theCondAction.ActionListObj = theActionList;
                                                    
                                                    theCondList.CondList[theCondList.CondList.length] = theCondAction;
                                                    
                                                    vtAddEventHandler(theHotspot.HotspotID + kEventsOffset_ProximityPOV, theCondList);
													contentText += "<div class='listItem'" + vtGetHTMLEventHandlerScript(theHotspot.HotspotID + kEventsOffset_ProximityPOV) + "><div class='left'>" + theHotspot.Title + "</div><div class='right'>&nbsp;</div><br class='clear'/></div>";
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        
                        contentText += "</div>";
                        break;
                    }
                    break;
                    
                case kVTTabTypeDetails:
                    {
                        contentText += "<div id='tabcDetails'>";
                        
                        if (theTab.Header != null)
                        {
                            contentText += "<div class='listHeader'><div class='left'>" + theTab.Header.Name + "</div><div class='right'>" + theTab.Header.Value + "</div><br class='clear'/></div>";
                        }
                        
                        if (theTab.RowListObj != null)
                        {
                            var curType = "";
                            var theRow = null;
                            
                            for (var idx1 = 0; idx1 < theTab.RowListObj.RowList.length; idx1++)
                            {
                                theRow = theTab.RowListObj.RowList[idx1];
                                if (curType != theRow.Type)
                                {
                                    contentText += "<div class='listTop'>" + theRow.Type + "</div>";
                                    curType = theRow.Type;
                                }
                                if (theRow.Header != null)
                                {
                                    if (theRow.CondListObj != null)
                                    {
                                        vtAddEventHandler(theRow.ID + kEventsOffset_DetailsTextRow, theRow.CondListObj);
                                        contentText += "<div class='listItem'" + vtGetHTMLEventHandlerScript(theRow.ID + kEventsOffset_DetailsTextRow) + "><div class='left'>" + vtXMLTextToHTML(vtASCIITextToHTML(theRow.Header.Name)) + "</div><div class='right'>" + vtXMLTextToHTML(vtASCIITextToHTML(theRow.Header.Value)) + "</div><br class='clear'/></div>";
                                    }
                                    else
			                            contentText += "<div class='listItemCopy'><div class='left'>" + vtXMLTextToHTML(vtASCIITextToHTML(theRow.Header.Name)) + "</div><div class='right'>" + vtXMLTextToHTML(vtASCIITextToHTML(theRow.Header.Value)) + "</div><br class='clear'/></div>";
                                }
                            }
                        }
                        
                        contentText += "</div>";
                        break;
                    }
                    break;
                    
                case kVTTabTypeMap:
                    if (theTab.MapObj != null && theTab.MapObj.Media != null)
                    {
                        contentText += "<div id='map'></div>";
                        theMapTab = theTab;
                        
                        if (theTab.MapObj.MarkerListObj != null)
                        {
                            var curType = "";
                            var theMarker = null;
                            
                            for (var idx1 = 0; idx1 < theTab.MapObj.MarkerListObj.MarkerList.length; idx1++)
                            {
                                theMarker = theTab.MapObj.MarkerListObj.MarkerList[idx1];
                                vtAddMapEventHandler(theMarker.ID, theMarker.CondListObj);
                            }
                        }
                    }
                    else
                        contentText += "Map not available.";
                    break;
                    
                default:
                    contentText += "Tab Panel ID=" + inTabListObj.TabList[idx].Type;
                    break;
            }
            contentText += "</div>";
            fullContentText += contentText;
        }
        // Create the Search tab
        contentText = "<div id='content" + kVTTabTypeSearch + "' style='display: none'>";
		contentText += "<div id='searchTable'>";
        
        if (theTab.Header != null)
        {
			contentText += "<div class='listHeader'><div class='left'>Search</div><div class='right'></div><br class='clear'/></div>";
        }
        
        contentText += "</div>";
        contentText += "</div>";
        fullContentText += contentText;
        gVTTarget_Tabs.innerHTML = fullContentText;
        
        if (theMapTab != null)
        {
            var theMapDiv;
            
            theMapDiv = document.getElementById("map");
            if (theMapDiv != null)
            {
                vtLoadMapDiv(theMapDiv, theMapTab.MapObj.Media, theMapTab.MapObj.MapXML);
            }
        }
    }
}

function vtLoadMapTab(inMapObj)
{
    if (gVTTarget_Tabs != null && inMapObj != null)
    {
        var theMapDiv;
        
        theMapDiv = document.getElementById("map");
        if (theMapDiv != null)
        {
            if (inMapObj.MarkerListObj != null)
            {
                var curType = "";
                var theMarker = null;
                
                for (var idx1 = 0; idx1 < inMapObj.MarkerListObj.MarkerList.length; idx1++)
                {
                    theMarker = inMapObj.MarkerListObj.MarkerList[idx1];
                    vtAddMapEventHandler(theMarker.ID, theMarker.CondListObj);
                }
            }
                    
            vtLoadMapDiv(theMapDiv, inMapObj.Media, inMapObj.MapXML);
        }
    }
}

function vtMakeFlashPanoXML(inPath, inPan, inTilt, inFOV, inHSXml)
{
    if (gbDebugOutput && gVTTarget_DebugOutput != null)
    {
        gVTTarget_DebugOutput.innerHTML += (++gDebugOutputCnt) + ": vtMakeFlashPanoXML(" + inPath + ")<br>";
        gVTTarget_DebugOutput.scrollTop = gVTTarget_DebugOutput.scrollHeight;
    }
        
    var theXML = "<?xml version = '1.0'?>\r";
    
    theXML += "<panorama>";
	theXML += "<parameters>";
    if (kVTLocalPanoFormat == 0)
    {
        // Support for MOV
        theXML += "layer_6  = files/cylConverter.swf;";
        theXML += "layer_7  = files/movDecoder.swf;";
    }
    if (gbVTUseAutoRotator)
        theXML += "layer_8 = files/autorotator.swf;";
    theXML += "layer_9  = files/hotspots.swf;";
    switch (kVTLocalPanoFormat)
    {
        case 0:
            theXML += "panoType = mov;";
            break;
        case 1:
            theXML += "panoType = stripe;";
            break;
        case 2:
            theXML += "panoType = cube;";
            break;
    }
    theXML += "panoName = ";
//    if (!gVTOnline && navigator.appName.indexOf("Microsoft") == 1)
//        theXML += "../"; 
    theXML += inPath + ";";
    theXML += "segments = 20;";
    theXML += "loaderStreamed = 0;";
//    theXML += "loaderStreamed = 1;";
//    theXML += "loaderBandwidth = 50;";
    theXML += "loaderText = ;";
    theXML += "shrink=1;";
    theXML += "qualityMotion=medium;";
    theXML += "qualityStatic=medium;";
    theXML += "pan = " + inPan + ";";
    theXML += "tilt = " + inTilt + ";";
    theXML += "hfov = " + inFOV + ";";
    theXML += "vfov = " + inFOV + ";";
    if (gbDebugOutput)
        vtDebugOutput("Pano XML Pan:" + inPan + " Tilt:" + inTilt + " FOV:" + inFOV);
    if (gbVTIsMicrosoftBrowser)
        theXML += "frameRate = 30;";
    theXML += "</parameters>";
    
    if (gbVTUseAutoRotator)
    {
        theXML += "<autorotator>";
        theXML += "speed = -0.3;";
        theXML += "interval = 30;";
        theXML += "pause = 7000;";
        theXML += "quality = medium;";
        theXML += "</autorotator>";
    }
    
    theXML += "<hotspots>";
    theXML += "<global ExternalInterfaceID='panoCtrl' onStart='javascript:vtPanoReady();'>";
//    theXML += "<spot static='1' url='externalTest.swf' />";
    theXML += inHSXml;
    theXML += "</global>";
    theXML += "</hotspots>";
    theXML += "</panorama>";
    
    return theXML;
}

function vtMakeFPPHotspotXML(inHotspot)
{
    var theXML = "";
    
    if (inHotspot != null)
    {
        if (inHotspot.CoordVRListObj != null)
        {
            var coordVR;
            for (var idx = 0; idx < inHotspot.CoordVRListObj.CoordVRList.length; idx++)
            {
                if (inHotspot.CoordVRListObj.CoordVRList[idx].Type == kVTCoordVRType_Exit)
                {
                    coordVR = inHotspot.CoordVRListObj.CoordVRList[idx];
                    theXML = "<spot pan='" + vtQTToFPPPanAngle(coordVR.Pan) + "' tilt='" + coordVR.Tilt + "' alpha='1.0' url='assets/";
                    
                    switch(parseInt(inHotspot.Category))
                    {
                        case kConCat_Hotel:
                            theXML += "hotel_icon";
                            break;
                        case kConCat_Condo:
                            theXML += "hotel_icon";
                            break;
                        case kConCat_Home:
                            theXML += "home_icon";
                            break;
                        case kConCat_Restaurant:
                            theXML += "restaurant_icon";
                            break;
                        case kConCat_Transportation:
                            theXML += "transportation_icon";
                            break;
                        case kConCat_Service:
                            theXML += "service_icon";
                            break;
                        case kConCat_Place:
                            theXML += "general_icon";
                            break;
                        case kConCat_Bar:
                            theXML += "bar_icon";
                            break;
                        case kConCat_Shop:
                            theXML += "shop_icon";
                            break;
                        case kConCat_Rental:
                            theXML += "rental_icon";
                            break;
                        case kConCat_Suite:
                            theXML += "hotel_icon";
                            break;
                        case kConCat_MeetingRoom:
                            theXML += "meetingroom_icon";
                            break;
                        case kConCat_Amenity:
                            theXML += "amenity_icon";
                            break;
                        case kConCat_Activity:
                            theXML += "activity_icon";
                            break;
                        case kConCat_Special:
                            theXML += "special_icon";
                            break;
                        case kConCat_Other:
                            theXML += "other_icon";
                            break;
                        default:
                            theXML += "general_icon";
                            break;
                    }
                     
                    theXML += ".png'";
                    theXML += " onClick='javascript:vtHandleEvent(" + inHotspot.HotspotID + ", " + kVTCondActionType_MouseClick + ")'";
                    theXML += " onOver='javascript:vtHandleEvent(" + inHotspot.HotspotID + ", " + kVTCondActionType_MouseEnter + ")'";
                    theXML += " onOut='javascript:vtHandleEvent(" + inHotspot.HotspotID + ", " + kVTCondActionType_MouseExit + ")'";
                    theXML += " onPress='javascript:vtHandleEvent(" + inHotspot.HotspotID + ", " + kVTCondActionType_MouseDown + ")'";
                    theXML += " onRelease='javascript:vtHandleEvent(" + inHotspot.HotspotID + ", " + kVTCondActionType_MouseUp + ")'";
                    theXML += " />";
                    break;
                }
            }
        }
    }
    
    return theXML;
}

function vtParseLauncherXML(inDocument)
{
    var locID = "";
    
    if (inDocument != null)
    {
        var launchTags = inDocument.getElementsByTagName("launch");
        if (launchTags != null && launchTags.length > 0)
        {
            locID = vtGetSubTagValue(launchTags[0], "ID");
            gVTOnline = (vtGetSubTagValue(launchTags[0], "Offline") != "1");
            gVTLanguage = vtGetSubTagValue(launchTags[0], "language");
            gVTRemoteURL = vtGetSubTagValue(launchTags[0], "remoteURL");
            if (gVTRemoteURL != "")
                gVTRemoteURL += "/";
            gVTProfile = vtGetSubTagValue(launchTags[0], "Profile");

            gVTOnLoadCondListObj = null;
                        
            var onLoadTag = vtGetSubTagTag(launchTags[0], "OnLoad");
            
            if (onLoadTag != null)
            {
                var condListTag = vtGetSubTagTag(onLoadTag, "CondList");
                
                if (condListTag != null)
                    gVTOnLoadCondListObj = new vtcCondList(condListTag);
            }
        }
    }
    
    return locID;
}

function vtGetInfoTemplateFromDocument(inDocument)
{
    if (window.console)
        window.console.log("GetInfoTemplateFromDocument start" + (inDocument != null));
    var theInfoTemplate = null;
    var theParams = new Array();
    var theRDTag = vtGetRDTagInDocument(inDocument, theParams);
    
    if (window.console)
        window.console.log("theParams.length" + theParams.length);
    if (theParams.length > 0)
    {
        gVTCurPlaceID = theParams[0];
        if (theParams.length > 1)
            gVTSessionID = theParams[1];
    }
    
    if (theRDTag != null)
    {
        if (window.console)
            window.console.log("Found RDTag");
        var lTag;
        
        if ((lTag = vtGetSubTagTag(theRDTag, "InfoTemplateObj")) != null)
            theInfoTemplate = new vtcInfoTemplate(lTag);
    }
    
    return theInfoTemplate;
}

function vtGetMapFromDocument(inDocument)
{
    if (window.console)
        window.console.log("GetMapObjFromDocument start" + (inDocument != null));
    var theMap = null;
    var theParams = new Array();
    var theRDTag = vtGetRDTagInDocument(inDocument, theParams);
    
    if (window.console)
        window.console.log("theParams.length" + theParams.length);
    if (theParams.length > 0)
    {
        gVTCurPlaceID = theParams[0];
        if (theParams.length > 1)
            gVTSessionID = theParams[1];
    }
    
    if (theRDTag != null)
    {
        if (window.console)
            window.console.log("Found RDTag");
        var lTag;
        
        if ((lTag = vtGetSubTagTag(theRDTag, "MapObj")) != null)
            theMap = new vtcMap(lTag);
    }
    
    return theMap;
}


//=====================================================
// Event Services
//=====================================================
var vtcEventHandler = function(inID, inCondList, inType)
{
    this.ID = inID;
    this.CondListObj = inCondList;
    this.Type = inType;
}

function vtClearEventHandlers()
{
    gEventHandlersList = null;
}

function vtClearMapEventHandlers()
{
    if (gEventHandlersList != null)
    {
        var newEventHandlersList = new Array();
        
        for (var idx = 0; idx < gEventHandlersList.length; idx++)
        {
            if (gEventHandlersList[idx].Type == 0)
                newEventHandlersList[newEventHandlersList.length] = new vtcEventHandler(gEventHandlersList[idx].ID, gEventHandlersList[idx].CondListObj, 0);
        }
        gEventHandlersList = null;
        gEventHandlersList = newEventHandlersList;
    }
}

function vtAddEventHandler(inID, inCondList)
{
    if (gEventHandlersList == null)
        gEventHandlersList = new Array();
    if (gEventHandlersList != null)
        gEventHandlersList[gEventHandlersList.length] = new vtcEventHandler(inID, inCondList, 0);
}

function vtAddMapEventHandler(inID, inCondList)
{
    if (gEventHandlersList == null)
        gEventHandlersList = new Array();
    if (gEventHandlersList != null)
        gEventHandlersList[gEventHandlersList.length] = new vtcEventHandler(inID, inCondList, 1);
}

var gVTDelayedLoadPlacePath = "";
var gVTDelayedLoadPlaceTweenPath = "";
var gVTLoadPlaceWithTweenPlacePath = "";
var gbVTTweenPlaying = false;

function vtDelayedLoadPlace()
{
    if (gbDebugOutput)
        vtDebugOutput("vtDelayedLoadPlace");
        
    if (gVTDelayedLoadPlacePath != "")
    {
        if (gVTDelayedLoadPlaceTweenPath != "")
        {
            vtLoadPlaceWithTween(gVTDelayedLoadPlaceTweenPath, gVTDelayedLoadPlacePath);
            gVTDelayedLoadPlaceTweenPath = "";
        }
        else
            vtLoadPlace(gVTDelayedLoadPlacePath, true);
    }
    gVTDelayedLoadPlacePath = "";
}

function vtLoadPlace(inPlacePath, inSaveAngles)
{
    if (gbDebugOutput)
        vtDebugOutput("vtLoadPlace(\"" + inPlacePath + "\")");
        
    if (!gVTIsHistoryNav && inSaveAngles)
    {
        var theHistory = vtHistoryGetCur();
        if (theHistory != null)
        {
            theHistory.Pan = vtGetPanAngle();
            theHistory.Tilt = vtGetTiltAngle();
            theHistory.FOV = vtGetFOVAngle();
        }
    }
    
    vtClearRemote();
    gLoadType = kVTLoadTypeLocation;
    
    if (gVTOnline == true)
    {
        thePlacePath = gVTServerPath + "?id=" + inPlacePath
        if (gVTProfile != "")
            thePlacePath += "&prof=" + gVTProfile;
        if (gVTSessionID != "")
            thePlacePath += "&sid=" + gVTSessionID;
        thePlacePath += "&vs=F" + kVTViewerVersion;
    }
    else
        thePlacePath = vtGetLanguagePrefix() + "/xml/" + inPlacePath + ".xml"
    
    if (window.console)
        window.console.log(thePlacePath);
    if (!gbVTTweenPlaying)
        vtSpinnerShow();
    vtGetRemoteXML(thePlacePath);
    gbVTPanoReady = false;
    
    if (gbVTTweenPlaying == false)
    {
//        if (gVTTarget_Tween != null)
//            gVTTarget_Tween.style.display = "none";
//        if (gVTTarget_Pano != null)
//            gVTTarget_Pano.style.display = "block";
//        if (gVTTarget_Tween != null)
//        {
//            //gVTTarget_Tween.style.display = "none";
//            gVTTarget_Tween.style.zIndex = -1;
//        }
//        if (gVTTarget_Pano != null)
//        {
//            //gVTTarget_Pano.style.display = "block";
//            gVTTarget_Pano.style.zIndex = 100;
//        }
    }
}

function vtLoadPlaceWithTween(inTweenPath, inPlacePath)
{
    if (gbDebugOutput && gVTTarget_DebugOutput != null)
    {
        gVTTarget_DebugOutput.innerHTML += (++gDebugOutputCnt) + ": vtLoadPlaceWithTween(\"" + inTweenPath + "\", \"" + inPlacePath + "\")<br>";
        gVTTarget_DebugOutput.scrollTop = gVTTarget_DebugOutput.scrollHeight;
    }
        
    if (!gVTIsHistoryNav)
    {
        var theHistory = vtHistoryGetCur();
        if (theHistory != null)
        {
            theHistory.Pan = vtGetPanAngle();
            theHistory.Tilt = vtGetTiltAngle();
            theHistory.FOV = vtGetFOVAngle();
        }
    }
    
    gVTLoadPlaceWithTweenPlacePath = inPlacePath;
    gbVTTweenPlaying = false;
    vtSpinnerShow();
    vtLoadTween(inTweenPath);
//    if (gVTTarget_Pano != null)
//        gVTTarget_Pano.style.display = "none";
//    if (gVTTarget_Tween != null)
//        gVTTarget_Tween.style.display = "block";

//    if (gVTTarget_Tween != null)
//    {
//        gVTTarget_Tween.style.zIndex = 100;
//    }
//    if (gVTTarget_Pano != null)
//    {
//        gVTTarget_Pano.style.zIndex = -1;
//    }
//    if (vtBrowserSupportOverlappedSWF())
//    {
//        vtLoadPlace(gVTLoadPlaceWithTweenPlacePath, false);
//        gVTLoadPlaceWithTweenPlacePath = "";
//    }
}

function vtLoadMap(inMapPath)
{
    if (gbDebugOutput)
        vtDebugOutput("vtLoadMap(\"" + inMapPath + "\")");
        
    var theMapPath = "";
    
    vtClearRemote();
    gLoadType = kVTLoadTypeMap;
    
    if (gVTOnline == true)
    {
        theMapPath = gVTServerPath + "?id=" + inMapPath
        if (gVTProfile != "")
            theMapPath += "&prof=" + gVTProfile;
        if (gVTSessionID != "")
            theMapPath += "&sid=" + gVTSessionID;
        theMapPath += "&vs=F" + kVTViewerVersion;
    }
    else
        theMapPath = vtGetLanguagePrefix() + "/xml/" + inMapPath + ".xml"
    
    if (window.console)
        window.console.log(theMapPath);
    vtGetRemoteXML(theMapPath);
}

var kOverlayAction_None = 0;
var kOverlayAction_ShowImage = 1;
var kOverlayAction_PlayVideo = 2;

var gVTOverlayAction = kOverlayAction_None;
var gVTOverlayActive = false;

var gbVTOverlayPanel_FadeIn = false;

var gVTOverlayPanel_CurOpacity = 100;
var gVTOverlayPanel_TargetOpacity = 100;
var gVTOverlayPanel_OpacityStep = 10;

function vtOverlayPanelFade()
{
    if (gVTOverlayPanel_CurOpacity != gVTOverlayPanel_TargetOpacity)
    {
            
    }
}

function vtShowImage(inImageURL)
{
    if (gbDebugOutput)
        vtDebugOutput("vtShowImage(\"" + inImageURL + "\")");
        
    if (gVTTarget_Overlay != null)
    {
        var splitString = inImageURL.split(".");    
        if (splitString[1] != "")
        {
            gVTTarget_Dimout.style.visibility = "visible";
            gVTTarget_Overlay.style.visibility = "visible";
            gVTTarget_Dimout.onclick = vtOverlayClick;
            //gVTTarget_Overlay.onclick = vtOverlayClick;
            
            var overlayContent = document.getElementById("overlayContent");
            var overlayControls = document.getElementById("overlayControls");
            var overlayText = document.getElementById("overlayText");
            
            var theImageURL;
            
            if (gVTOnline)
                theImageURL = gVTRemoteURL + inImageURL;
            else
                theImageURL = inImageURL;
            
            if (splitString[1].toLowerCase() == "swf")
            {
                gOverlay = vtCreateSWObject(theImageURL, "brand", "200", "70", "9", "#000000"); 
                gOverlay.addParam("wmode", "opaque");
                gOverlay.write(overlayContent);
                
                overlayContent.innerHTML = "<div id='overlayArea' style='text-align: left vertical-align: middle'>" + overlayContent.innerHTML + "</div>";
            }
            else
            {
                overlayContent.innerHTML = "<img src='" + theImageURL + "'>";
            }
            if (overlayText != null)
                overlayText.innerHTML = "";
            if (overlayControls != null)
            {
                var theHTML;
                
                theHTML = "<img src='assets/btnreturn.png' style='cursor: pointer;' width=124 height=28 onclick='vtOverlayClick();'>";
                if (gbVTCompactMode)
                    theHTML += "<img src='assets/btninfo.png' id='overlayBtnInfo' style='cursor: pointer;' onmouseover='vtOverlayInfoMouseOver(1);' onclick='vtOverlayInfoClick(1)'/>";
                overlayControls.innerHTML = theHTML;
            }
            gVTOverlayActive = true;
        }
    }
}

var gVTVideoURL = "";

function vtPlayVideo(inVideoURL, inContinueTo, inAutoContinue)
{
    if (gbDebugOutput)
        vtDebugOutput("vtPlayVideo(\"" + inVideoURL + "\")");
        
    if (gVTTarget_OverlayVideo != null)
    {
        gVTTarget_Dimout.style.visibility = "visible";
        gVTTarget_OverlayVideo.style.visibility = "visible";
        gVTTarget_Dimout.onclick = vtOverlayClick;
        //gVTTarget_OverlayVideo.onclick = vtOverlayClick;
        
        var overlayVideoText = document.getElementById("overlayVideoText");
        if (overlayVideoText != null)
            overlayVideoText.innerHTML = "";
        
        var fileName = inVideoURL.substring(0, inVideoURL.lastIndexOf("."));
        
        if (gVTOnline)
            gVTVideoURL = gVTRemoteURL + fileName + ".flv";
        else
            gVTVideoURL = fileName + ".flv";
            
        setTimeout(vtDelayedPlayVideo, 500);
        gbPlayVideo = true;
        
        gVTOverlayActive = true;
        
        gbVTPlayVideoAutoContinue = inAutoContinue;
        gVTPlayVideoContinueTo = inContinueTo;
    }
}

var gLastTweenFLVPath = "";
var gLastVideoFLVPath = "";

function vtDelayedPlayVideo()
{
    if (gbDebugOutput)
        vtDebugOutput("vtDelayedPlayVideo(\"" + gVTVideoURL + "\")");
        
    if (gbVTIsMicrosoftBrowser)
        gFlashVideoPlayerObj = window["video"];
    else
        gFlashVideoPlayerObj = document["video"];
        
    if (gFlashVideoPlayerObj != null)
    {
        //gFlashVideoPlayerObj.onClick = vtOverlayClick;
        
        var overlayVideoContent = document.getElementById("overlayVideoContent");
        var overlayVideoControls = document.getElementById("overlayVideoControls");
        if (overlayVideoControls != null)
        {
            var theHTML = "";
            
            theHTML = "<img src='assets/btnreturn.png' style='cursor: pointer;' width=124 height=28 onclick='vtOverlayClick();'>";
            if (gVTPlayVideoContinueTo != "")
            {
                theHTML += "<img src='assets/btncontinue.png' style='cursor: pointer;' width=128 height=28 onclick='vtOverlayContinueClick();'>";
            }
            if (gbVTCompactMode)
                theHTML += "<img src='assets/btninfo.png' id='overlayBtnInfo' style='cursor: pointer;' onmouseover='vtOverlayInfoMouseOver(2);' onclick='vtOverlayInfoClick(2)'/>";
            overlayVideoControls.innerHTML = theHTML;
        }
            
        if (gLastVideoFLVPath == gVTVideoURL)
        {
            gFlashVideoPlayerObj.flvControl('rewind');
            gFlashVideoPlayerObj.showLayer('flv');
            gFlashVideoPlayerObj.flvControl('play');
        }
        else
        {
            gLastVideoFLVPath = gVTVideoURL;
            vtVideoSpinnerShow();
            
            if (gVTVideoURL.indexOf(":") >= 0)
                gFlashVideoPlayerObj.flvLoad(gVTVideoURL);
            else
                gFlashVideoPlayerObj.flvLoad("../" + gVTVideoURL);
            //gFlashVideoPlayerObj.flvControl("showcontrols");
            //gFlashVideoPlayerObj.flvLoad(gVTVideoURL);
        }
    }
}

function vtOverlayClick()
{
    if (gVTTarget_Overlay != null)
    {
        gVTTarget_Dimout.style.visibility = "hidden";
        if (gVTTarget_Overlay.style.visibility == "visible")
            gVTTarget_Overlay.style.visibility = "hidden";
        if (gVTTarget_OverlayVideo.style.visibility == "visible")
            gVTTarget_OverlayVideo.style.visibility = "hidden";
        
        if (gbPlayVideo && gFlashVideoPlayerObj != null)
        {
            gFlashVideoPlayerObj.flvControl('pause');
  	        gFlashVideoPlayerObj.showLayer('pano');
  	    }
  	    gbPlayVideo = false;
        gVTOverlayActive = false;
        
        if (gbVTCompactMode)
            vtDismissOverlayText(gVTOverlayInfoDisplayMode);
    }
}

function vtOverlayContinueClick()
{
    if (gVTTarget_Overlay != null)
    {
        if (gbPlayVideo)
        {
            try
            {
                gFlashVideoPlayerObj.flvControl('pause');
            }
            catch(e)
            {
            }
  	    }
  	    
        if (gVTPlayVideoContinueTo != "" && gVTPlayVideoContinueTo != "0")
        {
            vtLoadPlace(gVTPlayVideoContinueTo, true);
            setTimeout(vtOverlayContinueCheckPanoLoaded, 500);
            vtSpinnerShow();
        }
        else
        {
  	        gFlashVideoPlayerObj.showLayer('pano');
            gVTTarget_Dimout.style.visibility = "hidden";
            if (gVTTarget_Overlay.style.visibility == "visible")
                gVTTarget_Overlay.style.visibility = "hidden";
            if (gVTTarget_OverlayVideo.style.visibility == "visible")
                gVTTarget_OverlayVideo.style.visibility = "hidden";
            
  	        gbPlayVideo = false;
            gVTOverlayActive = false;
        }
        
        if (gbVTCompactMode)
            vtDismissOverlayText(gVTOverlayInfoDisplayMode);
    }
}

function vtOverlayContinueCheckPanoLoaded()
{
    if (gbDebugOutput)
        vtDebugOutput("vtOverlayContinueCheckPanoLoaded()");
        
    if (gbVTPanoReady == true)
    {
 	    gFlashVideoPlayerObj.showLayer('pano');
        gVTTarget_Dimout.style.visibility = "hidden";
        if (gVTTarget_Overlay.style.visibility == "visible")
            gVTTarget_Overlay.style.visibility = "hidden";
        if (gVTTarget_OverlayVideo.style.visibility == "visible")
            gVTTarget_OverlayVideo.style.visibility = "hidden";
        
        gbPlayVideo = false;
        gVTOverlayActive = false;
        vtSpinnerHide();
    }
    else
        setTimeout(vtOverlayContinueCheckPanoLoaded, 500);
}

function vtXMLTextToHTML(inXMLText)
{
    var retStr = "";
    var regExp = /&amp;/gi;
    
    retStr = inXMLText.replace(regExp, "&");
    regExp = /&lt;/gi;
    retStr = retStr.replace(regExp, "<");
    regExp = /&gt;/gi;
    retStr = retStr.replace(regExp, ">");
    regExp = /&quot;/gi;
    retStr = retStr.replace(regExp, "\"");
    regExp = /&apos;/gi;
    retStr = retStr.replace(regExp, "'");
    
    return retStr;
}

function vtASCIITextToHTML(inASCIIText)
{
    var theText
    var regExp = /\r\n/gi;
    
    theText = inASCIIText.replace(regExp, "<br>");
    regExp = /\n\r/gi;
    theText = theText.replace(regExp, "<br>");
    regExp = /\r/gi;
    theText = theText.replace(regExp, "<br>");
    regExp = /\n/gi;
    theText = theText.replace(regExp, "<br>");
    regExp = /&amp;#8208;/gi;
    theText = theText.replace(regExp, "-");
    
    return theText;
}

function vtExecuteAction(inAction)
{
    var bActionExecuted = false;

    if (inAction != null)
    {
        var param1 = null;
        var param2 = null;
        var param3 = null;
        var param4 = null;
        var thePath = "";
        
        switch (parseInt(inAction.Type))
        {
            case kVTActionType_LoadPlace:
                if (inAction.ParamListObj != null)
                {
                    param1 = inAction.ParamListObj.ParamList[0];
                    if (inAction.ParamListObj.ParamList.length > 1)
                        param2 = inAction.ParamListObj.ParamList[1];
                    if (inAction.ParamListObj.ParamList.length > 2)
                        param3 = inAction.ParamListObj.ParamList[2];
                }
                if (param1 != gVTCurPlaceID)
                {
                    vtClearRemote();
                    if (param2 != null)
                    {
                        gVTLoadPlaceUseEnterAngles = true;
                        gVTLoadPlaceEnterPan = param2.Pan;
                        gVTLoadPlaceEnterTilt = param2.Tilt;
                        gVTLoadPlaceEnterFOV = param2.FOV;
                    }
                    if (param3 != null)
                    {
                        vtSetPanAngleBy(vtGetPanAngleDelta(vtGetPanAngle(), vtQTToFPPPanAngle(parseInt(param3.Pan))), 250);
                        vtSetTiltAngleTo(param3.Tilt, 250);
                        vtSetFOVAngleTo(param3.FOV, 250);
                    }
                    thePath = param1;
                    gUseFadeIn = true;
                    if (param2 == null)
                        vtLoadPlace(thePath, true);
                    else
                    {
                        gVTDelayedLoadPlacePath = thePath;
                        setTimeout(vtDelayedLoadPlace, 1000);
                    }
                    bActionExecuted = true;
                }
                break;
            case kVTActionType_LoadPlaceWithTransition:
                if (inAction.ParamListObj != null)
                {
                    param1 = inAction.ParamListObj.ParamList[0];
                    if (inAction.ParamListObj.ParamList.length > 1)
                        param2 = inAction.ParamListObj.ParamList[1];
                    if (inAction.ParamListObj.ParamList.length > 2)
                        param3 = inAction.ParamListObj.ParamList[2];
                    if (inAction.ParamListObj.ParamList.length > 3)
                        param4 = inAction.ParamListObj.ParamList[3];
                }
                if (param1 != gVTCurPlaceID)
                {
                    vtClearRemote();
                    if (param2 != null)
                    {
                        gVTLoadPlaceUseEnterAngles = true;
                        gVTLoadPlaceEnterPan = param2.Pan;
                        gVTLoadPlaceEnterTilt = param2.Tilt;
                        gVTLoadPlaceEnterFOV = param2.FOV;
                    }
                    if (param3 != null)
                    {
                        vtSetPanAngleBy(vtGetPanAngleDelta(vtGetPanAngle(), vtQTToFPPPanAngle(parseInt(param3.Pan))), 250);
                        vtSetTiltAngleTo(param3.Tilt, 250);
                        vtSetFOVAngleTo(param3.FOV, 250);
                    }
                    thePath = param1;
                    if (param2 == null)
                    {
                        gUseFadeIn = true;
                        vtLoadPlaceWithTween(param4.URL, thePath);
                    }
                    else
                    {
                        gUseFadeIn = false;
                        gVTDelayedLoadPlacePath = thePath;
                        gVTDelayedLoadPlaceTweenPath = param4.URL;
                        setTimeout(vtDelayedLoadPlace, 1000);
                    }
                    bActionExecuted = true;
                }
                break;
            case kVTActionType_ShowText:
                if (inAction.ParamListObj != null)
                    param1 = inAction.ParamListObj.ParamList[0];
                if (!gVTOverlayActive)
                {
                    //if (gVTTarget_Status != null)
                        //gVTTarget_Status.innerHTML = param1;
                    vtShowToolTip(param1);
                }
                else
                {
                    var overlayText = null;
                    
                    if (!gbPlayVideo)
                        overlayText = document.getElementById("overlayText");
                    else
                        overlayText = document.getElementById("overlayVideoText");
                        
                    if (overlayText != null)
                    {
                        overlayText.innerHTML = "<font color=#ffffff>" + vtXMLTextToHTML(vtASCIITextToHTML(param1)) + "</font>";
                    }
                }
                bActionExecuted = true;
                break;
            case kVTActionType_ShowPOV:
                if (inAction.ParamListObj != null && inAction.ParamListObj.ParamList.length == 3)
                {
                    param1 = inAction.ParamListObj.ParamList[0];
                    param2 = inAction.ParamListObj.ParamList[1];
                    param3 = inAction.ParamListObj.ParamList[2];
                    vtSetPanAngleBy(vtGetPanAngleDelta(vtGetPanAngle(), vtQTToFPPPanAngle(parseInt(param1))), kVTSwingToTime);
                    vtSetTiltAngleTo(parseInt(param2), kVTSwingToTime);
                    vtSetFOVAngleTo(parseInt(param3), kVTSwingToTime);
                    gVTPanAnglePolingEnabled = true;
                    setTimeout(vtPolePanAngle, 500);
                    bActionExecuted = true;
                }
                break;
            case kVTActionType_LoadVideoURL:
                if (inAction.ParamListObj != null && inAction.ParamListObj.ParamList.length >= 1)
                {
                    var bAutoContinue = false;
                    var continueTo = 0;
                    
                    if (inAction.ParamListObj.ParamList.length >= 2)
                        continueTo = inAction.ParamListObj.ParamList[1];
                    if (inAction.ParamListObj.ParamList.length == 3)
                    {
                        if (inAction.ParamListObj.ParamList[2] == "1")
                            bAutoContinue = true;
                    }
                    
                    vtPlayVideo(inAction.ParamListObj.ParamList[0], continueTo, bAutoContinue);
                    bActionExecuted = true;
                    
                }
                break;
            case kVTActionType_ShowImage:
                if (inAction.ParamListObj != null && inAction.ParamListObj.ParamList.length == 1)
                {
                    vtShowImage(inAction.ParamListObj.ParamList[0]);
                    bActionExecuted = true;
                }
                break;
            case kVTActionType_LoadMap:
                if (inAction.ParamListObj != null && inAction.ParamListObj.ParamList.length == 1)
                {
                    vtLoadMap(inAction.ParamListObj.ParamList[0]);
                    bActionExecuted = true;
                }
                break;
            case kVTActionType_GoBrowserURL:
                if (inAction.ParamListObj != null)
                    param1 = inAction.ParamListObj.ParamList[0];
                window.open(param1, "VTourGoBrowserURL");
                bActionExecuted = true;
                break;
        }
    }
    
    return bActionExecuted;
}

function vtHandleEvent(inID, inEventID)
{
    if (gEventHandlersList != null)
    {
        var theHandler, bActionExecuted = false;
        
        if (inEventID != kVTCondActionType_MouseMoved)
            vtHideToolTip();
        
        for (var idx = 0; idx < gEventHandlersList.length; idx++)
        {
            theHandler = gEventHandlersList[idx];
            if (parseInt(theHandler.ID) == inID && theHandler.CondListObj != null)
            {
                var condObj
                for (var idx1 = 0; idx1 < theHandler.CondListObj.CondList.length; idx1++)
                {
                    condObj = theHandler.CondListObj.CondList[idx1];
                    if (parseInt(condObj.Type) == inEventID)
                    {
                        if (condObj.ActionListObj != null)
                        {
                            for (var idx2 = 0; idx2 < condObj.ActionListObj.ActionList.length; idx2++)
                                if (vtExecuteAction(condObj.ActionListObj.ActionList[idx2]))
                                    bActionExecuted = true;
                        }
                    }
                }
                break;
            }
        }
        
        if (gbVTCompactMode && inEventID == kVTCondActionType_MouseClick)
        {
            vtNavDeselectCurTab();
            vtDismissTabContent();        
        }
    }
}

function markerEvent(inID, inEventID)
{
    vtHandleEvent(inID, inEventID);
}

function vtGoToPlace(inPlaceID)
{
    if (gbDebugOutput)
        vtDebugOutput("vtGoToPlace");
        
    gUseFadeIn = true;
    if (inPlaceID != "" && inPlaceID != gVTCurPlaceID)
        vtLoadPlace(inPlaceID, true);
        
    if (gbVTCompactMode)
    {
        vtNavDeselectCurTab();
        vtDismissTabContent();        
    }
}


//=====================================================
// Initialization Services
//=====================================================
function vtCoreInitialize()
{
    if (kVTourVersion != kVTCoreVersion || kVTViewerVersion != kVTCoreVersion || kVTViewerVersion != kVTObjectsVersion || kVTViewerVersion != kVTNavVersion || kVTViewerVersion != kVTToolTipVersion)
        alert("Code mis-match in player script!");

    gbVTIsMicrosoftBrowser = (navigator.appName.indexOf("Microsoft") != -1);
    
    try
    {
        vtToolTipInitialize();
    }
    catch (e)
    {
    }
    
    try
    {
        vtPreInitialize();
    }
    catch (e)
    {
    }
    
    gVTTarget_Pano = document.getElementById(gVTContainerName_Pano);
    gVTTarget_Tween = document.getElementById(gVTContainerName_Tween);
    gVTTarget_Location = document.getElementById(gVTContainerName_Location);
    gVTTarget_Status = document.getElementById(gVTContainerName_Status);
    gVTTarget_Tabs = document.getElementById(gVTContainerName_Tabs);
    gVTTarget_Brand = document.getElementById(gVTContainerName_Brand);
    gVTTarget_Banner = document.getElementById(gVTContainerName_Banner);
    gVTTarget_Dimout = document.getElementById(gVTContainerName_Dimout);
    gVTTarget_Overlay = document.getElementById(gVTContainerName_Overlay);
    gVTTarget_OverlayVideo = document.getElementById(gVTContainerName_OverlayVideo);
    gVTTarget_DebugOutput = document.getElementById(gVTContainerName_DebugOutput);
    
    if(gbVTIsMicrosoftBrowser)
        gFlashTweenObj = window["pano"];
    else
        gFlashTweenObj = document["pano"];
    
    gFlashVideoPlayerObj = document.getElementById("video");

    if (gbDebug)    
        document.getElementById("breakBtn").style.visibility = "visible";
    
    if (gbDebugOutput)
    {
        gVTTarget_DebugOutput = document.getElementById(gVTContainerName_DebugOutput);
        if (gVTTarget_DebugOutput != null)
        {
            gVTTarget_DebugOutput.style.visibility = "visible";
            gVTTarget_DebugOutput.style.display = "block";
        }
        vtDebugOutput("TGFlash Player: " + gVTPlayerName + " v" + kVTViewerVersion);
    }
    
    vtSetStateChangeHandler(vtLoadStateChangeHandler);
    
    try
    {
        gVTServerPath = kVTLocalServerPath;
    }
    catch (e)
    {
    }
    if (gVTServerPath == "")
        alert("Server path is empty!");
        
    try
    {
        vtPostInitialize();
    }
    catch (e)
    {
    }
}

function vtStartFromLauncher(inLauncherURL)
{
    gLoadType=kVTLoadTypeLauncher;
    vtGetRemoteXML(inLauncherURL);
}

function vtStart()
{
    var profileID = vtGetQueryParameter("pid");
    var launchID = vtGetQueryParameter("lid");
    
    document.title = gVTPlayerName + " (v" + kVTViewerVersion + ")";
    
    if (gbDebugOutput)
        vtDebugOutput("vtStart");
        
    if (launchID != "" && profileID !="")
    {
		vtStartFromLauncher("launchers/" + profileID + "/" + launchID + ".xml");
    }
    else
        vtStartFromLauncher("launcher.xml");
}

//=====================================================
// Misc. Services
//=====================================================
function vtPanoReady()
{
    if (gbDebugOutput)
        vtDebugOutput("vtPanoReady");
        
    if (gUseFadeIn)
    {
        gVTSetPOVDuration = 1000;
        setTimeout(vtDelayedSetPOV, 1000);
    }
    else
    {
        if (gbVTPanoReady)
        {    
            vtSetPanAngleTo(gEnterPan, 0);
            vtSetTiltAngleTo(gEnterTilt, 0);
            vtSetFOVAngleTo(gEnterFOV, 0);
        }
        else
        {
            if (!(gbVTUseAutoRotator && gbVTTweenPlaying))
                setTimeout(vtDelayedSetPOV, 100);
        }
    }
}

function panoReady () 
{
    if (gbDebugOutput)
        vtDebugOutput("panoReady");
        
    vtSpinnerHide();
    gbVTPanoReady = true;
    if (!gbVTTweenPlaying)
    {
        setTimeout(delayedShowPano, 500);
        vtSpinnerHide();
    }
}

function vtDelayedSetPOV()
{
    if (gbDebugOutput)
        vtDebugOutput("vtDelayedSetPOV");
    
    if (gbVTPanoReady)
    {    
        vtSetPanAngleTo(gEnterPan, gVTSetPOVDuration);
        vtSetTiltAngleTo(gEnterTilt, gVTSetPOVDuration);
        vtSetFOVAngleTo(gEnterFOV, gVTSetPOVDuration);
        if (gbDebugOutput)
            vtDebugOutput("Pan:" + gEnterPan + " Tilt:" + gEnterTilt + " FOV:" + gEnterFOV);
        gVTSetPOVDuration = 0;
    }
    else
        setTimeout(vtDelayedSetPOV, 100);
}

function flvComplete()
{
    if (gbDebugOutput)
        vtDebugOutput("flvComplete");
        
    gbVTTweenPlaying = false;
    if (!vtBrowserSupportOverlappedSWF() && gVTLoadPlaceWithTweenPlacePath != "")
    {
        vtLoadPlace(gVTLoadPlaceWithTweenPlacePath, false);
        gVTLoadPlaceWithTweenPlacePath = "";
    }
    
    if (!gbPlayVideo)
    {
        if (gbVTUseAutoRotator)
            vtDelayedSetPOV();
        
        if (gbDebugOutput)
            vtDebugOutput("gbVTPanoReady=" + gbVTPanoReady);
        if (gbVTPanoReady)
            setTimeout(delayedShowPano, 500);
        else
            vtSpinnerShow();
    }
    else
    {
        if (gbVTPlayVideoAutoContinue)
            vtOverlayContinueClick();
        gbVTPlayVideoAutoContinue = false;
        gVTPlayVideoContinueTo = "";
    }
    
}

var gbPlayVideo = false;

function flvReady () 
{
    if (gbDebugOutput)
        vtDebugOutput("flvReady");
        
    if (!gbPlayVideo)
        vtSpinnerHide();
    else
        vtVideoSpinnerHide();
    if (!gbPlayVideo)
    {
        if (gFlashTweenObj != null)
        {
            gFlashTweenObj.showLayer('flv');
            setTimeout(delayedPlay, 100);
            gbVTTweenPlaying = true;
            
            if (vtBrowserSupportOverlappedSWF())
            {
                vtLoadPlace(gVTLoadPlaceWithTweenPlacePath, false);
                gVTLoadPlaceWithTweenPlacePath = "";
            }
	    }
	}
	else
	{
	    if (gFlashVideoPlayerObj != null)
	    {
	        gFlashVideoPlayerObj.showLayer('flv');
            setTimeout(delayedPlay, 100);
	    }
	}
}

function delayedPlay()
{
    if (gbDebugOutput)
        vtDebugOutput("delayedPlay");
        
    if (!gbPlayVideo)
    {
        if (gFlashTweenObj != null)
            gFlashTweenObj.flvControl('play');
    }
    else
    {
        if (gFlashVideoPlayerObj != null)
            gFlashVideoPlayerObj.flvControl('play');
    }
}

function delayedShowPano()
{
    gFlashTweenObj.showLayer('pano');
}

function vtBrowserSupportOverlappedSWF()
{
    var agt = navigator.userAgent.toLowerCase();
    if (agt.indexOf("msie") != -1)
        return true;
    if (agt.indexOf("safari") != -1)
        return true;
        
    return true;
}

function vtGetQueryParameter(inParamName) 
{  
    var query = window.location.search.substring(1);  
    var vars = query.split("&");  
    
    for (var i=0; i<vars.length; i++) 
    {    
        var pair = vars[i].split("=");
        
        if (pair[0] == inParamName) 
            return pair[1];    
    }   
    
    return "";
}

var gbPanoSpinnerShown = false;
var gbVideoSpinnerShown = false;

function vtSpinnerShow()
{
    gbPanoSpinnerShown = vtPlayerSpinnerShow("pano", gbPanoSpinnerShown);
}

function vtSpinnerHide()
{
    gbPanoSpinnerShown = vtPlayerSpinnerHide("pano", gbPanoSpinnerShown);
}

function vtVideoSpinnerShow()
{
    gbVideoSpinnerShown = vtPlayerSpinnerShow("video", gbVideoSpinnerShown);
}

function vtVideoSpinnerHide()
{
    gbVideoSpinnerShown = vtPlayerSpinnerHide("video", gbVideoSpinnerShown);
}

function vtPlayerSpinnerShow(inID, inSpinnerShown)
{
    var bRet = inSpinnerShown;
    try
    {
        if (!inSpinnerShown)
        {
            vtGetSWFObject(inID).setSpinner('show');
            bRet = true;
        }
    }
    catch(e)
    {
    }
    return bRet;
}

function vtPlayerSpinnerHide(inID, inSpinnerShown)
{
    var bRet = inSpinnerShown;
    try
    {
        if (inSpinnerShown)
        {
            vtGetSWFObject(inID).setSpinner('hide');
            bRet = false;
        }
    }
    catch(e)
    {
    }
    return bRet;
}

function vtEvalSound(inSoundURL)
{
    document.getElementById("soundSpan").innerHTML = "<embed src='" + inSoundURL + "' hidden=true autostart=true loop=false>";
}

function vtDebugOutput(inDebugOutputText)
{
    if (gbDebugOutput && gVTTarget_DebugOutput != null)
    {
        gVTTarget_DebugOutput.innerHTML += (++gDebugOutputCnt) + ": " + inDebugOutputText + "<br>";
        gVTTarget_DebugOutput.scrollTop = gVTTarget_DebugOutput.scrollHeight;
    }
}

var gFadeTarget = null;
var gFadeEnd;

var gFadeCurrent;
var gFadeStep;
var gFadeTaskID = 0;
var gFadeShowZIndex = -1000;
var gFadeHideZIndex = -1000;

function vtFadeTarget(inTarget, inStartOpacity, inEndOpacity, inSteps, inShowZIndex, inHideZIndex)
{
    if (gbDebugOutput)
        vtDebugOutput("vtFadeTarget");
    
    if (gFadeTaskID > 0)    
        clearInterval(gFadeTaskID);
        
    gFadeTarget = inTarget;
    gFadeCurrent = inStartOpacity;
    gFadeEnd = inEndOpacity;
    gFadeShowZIndex = inShowZIndex;
    gFadeHideZIndex = inHideZIndex;
    gFadeStep = (inEndOpacity - inStartOpacity) / inSteps;
    if (gbDebugOutput)
        vtDebugOutput("gFadeCurrent=" + gFadeCurrent + ": gFadeEnd=" + gFadeEnd + ": gFadeStep=" + gFadeStep);
    if (gFadeStep > 0 && gFadeShowZIndex != -10000)
        gFadeTarget.style.zIndex = gFadeShowZIndex;
    vtFadeSet(gFadeCurrent);
    gFadeTaskID = setInterval(vtFadeLoop, 50);
}

function vtFadeLoop()
{
    if (gbDebugOutput)
        vtDebugOutput("vtFadeLoop(gFadeCurrent=" + gFadeCurrent + ": gFadeEnd=" + gFadeEnd + ")");
    if (gFadeTarget != null)
    {
        if (gFadeCurrent != gFadeEnd)
        {
            gFadeCurrent += gFadeStep;
            if (gFadeStep > 0)
            {
                if (gFadeCurrent > gFadeEnd)
                    gFadeCurrent = gFadeEnd;
            }
            else
            {
                if (gFadeCurrent < gFadeEnd)
                    gFadeCurrent = gFadeEnd;
            }
            vtFadeSet(gFadeCurrent);
        }
        else
        {
            if (gFadeCurrent == 0 && gFadeShowZIndex != -10000)
                gFadeTarget.style.zIndex = gFadeHideZIndex;
            clearInterval(gFadeTaskID);
        }
    }
}

function vtFadeSet(inOpacity)
{
    if (gFadeTarget.style.opacity != null)
        gFadeTarget.style.opacity = inOpacity / 100;
    if (gFadeTarget.style.MozOpacity != null)
        gFadeTarget.style.MozOpacity = inOpacity / 100;
    if (gFadeTarget.style.KhtmlOpacity != null)
        gFadeTarget.style.KhtmlOpacity = inOpacity / 100;
    gFadeTarget.style.filter = "alpha(opacity=" + inOpacity + ")";
}

var gbVTOverlayInfoDisplayed = false;
var gVTOverlayInfoDisplayMode = 0;

function vtOverlayInfoMouseOver(inDisplay)
{
    if (gbDebugOutput)
        vtDebugOutput("vtOverlayInfoMouseOver()");
    
    if (!gbVTOverlayInfoDisplayed)
        vtRevealOverlayText(inDisplay);
}

//function vtOverlayInfoMouseOut(inDisplay)
//{
//    if (gbDebugOutput)
//        vtDebugOutput("vtOverlayInfoMouseOut()");
//    
//    if (gbVTOverlayInfoDisplayed)
//    {    
//        var divName;
//        
//        if (inDisplay == 1)
//            divName = "overlayText";
//        else
//            divName = "overlayVideoText";
//        gFadeTarget = document.getElementById(divName);
//        vtFadeSet(90);
//        vtFadeTarget(document.getElementById(divName), 80, 0, 5, 1003, -1);
//        if (document.getElementById(divName + "Underlay"))
//           document.getElementById(divName + "Underlay").style.display = "none";
//       gbVTOverlayInfoDisplayed = false;
//    }
//}

function vtOverlayInfoClick(inDisplay)
{
    if (gbDebugOutput)
        vtDebugOutput("vtOverlayInfoMouseOut()");
    
    if (gbVTOverlayInfoDisplayed)    
        vtDismissOverlayText(inDisplay);
    else
        vtRevealOverlayText(inDisplay);
}

function vtRevealOverlayText(inDisplay)
{
    if (gbDebugOutput)
        vtDebugOutput("vtRevealOverlayText()");

    if (!gbVTOverlayInfoDisplayed)
    {    
        var divName;
        
        gVTOverlayInfoDisplayMode = inDisplay;
        if (inDisplay == 1)
            divName = "overlayText";
        else
            divName = "overlayVideoText";
        if (document.getElementById(divName + "Underlay"))
        {
            document.getElementById(divName + "Underlay").style.display = "block";
            document.getElementById(divName + "Underlay").style.visibility = "visible";
            document.getElementById(divName + "Underlay").onmouseover = vtOverlayTextUnderlayMouseOver;
        }
        gFadeTarget = document.getElementById(divName);
        vtFadeSet(0);
        vtFadeTarget(document.getElementById(divName), 0, 80, 5, 1003, -1);
        gbVTOverlayInfoDisplayed = true;
    }
}

function vtDismissOverlayText(inDisplay)
{
    if (gbDebugOutput)
        vtDebugOutput("vtDismissOverlayText()");
        
    if (gbVTOverlayInfoDisplayed)
    {    
        var divName;
        
        if (inDisplay == 1)
            divName = "overlayText";
        else
            divName = "overlayVideoText";
        gFadeTarget = document.getElementById(divName);
        vtFadeSet(90);
        vtFadeTarget(document.getElementById(divName), 80, 0, 5, 1003, -1);
        if (document.getElementById(divName + "Underlay"))
           document.getElementById(divName + "Underlay").style.display = "none";
       gbVTOverlayInfoDisplayed = false;
    }
}

function vtOverlayTextUnderlayMouseOver()
{
    if (gbDebugOutput)
        vtDebugOutput("vtOverlayTextUnderlayMouseOver()");
    
    vtDismissOverlayText(gVTOverlayInfoDisplayMode);
}