///////////////////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
//  Silverlight.js   			version 2.0.31030.0਍ഀ
//਍ഀ
//  This file is provided by Microsoft as a helper file for websites that਍ഀ
//  incorporate Silverlight Objects. This file is provided under the Microsoft਍ഀ
//  Public License available at ਍ഀ
//  http://code.msdn.microsoft.com/silverlightjs/Project/License.aspx.  ਍ഀ
//  You may not use or distribute this file or the code in this file except as ਍ഀ
//  expressly permitted under that license.਍ഀ
// ਍ഀ
//  Copyright (c) Microsoft Corporation. All rights reserved.਍ഀ
//਍ഀ
///////////////////////////////////////////////////////////////////////////////਍ഀ
਍ഀ
if (!window.Silverlight)਍ഀ
{਍ഀ
    window.Silverlight = { };਍ഀ
}਍ഀ
਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// _silverlightCount:਍ഀ
//਍ഀ
// Counter of globalized event handlers਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight._silverlightCount = 0;਍ഀ
਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// __onSilverlightInstalledCalled:਍ഀ
//਍ഀ
// Prevents onSilverlightInstalled from being called multiple ਍ഀ
// times਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.__onSilverlightInstalledCalled = false;਍ഀ
਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// fwlinkRoot:਍ഀ
//਍ഀ
// Prefix for fwlink URL's਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.fwlinkRoot='http://go2.microsoft.com/fwlink/?LinkID=';਍ഀ
਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// __installationEventFired:਍ഀ
//਍ഀ
// Ensures that only one Installation State event is fired.਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.__installationEventFired = false;਍ഀ
਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//  ਍ഀ
// onGetSilverlight:਍ഀ
//਍ഀ
// Called by Silverlight.GetSilverlight to notify the page that a user਍ഀ
// has requested the Silverlight installer਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.onGetSilverlight = null;਍ഀ
਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// onSilverlightInstalled:਍ഀ
//਍ഀ
// Called by Silverlight.WaitForInstallCompletion when the page detects਍ഀ
// that Silverlight has been installed. The event handler is not called਍ഀ
// in upgrade scenarios.਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.onSilverlightInstalled = function () {window.location.reload(false);};਍ഀ
਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// isInstalled:਍ഀ
//਍ഀ
// Checks to see if the correct version is installed਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.isInstalled = function(version)਍ഀ
{਍ഀ
    if (version == undefined)਍ഀ
        version = null;਍ഀ
        ਍ഀ
    var isVersionSupported = false;਍ഀ
    var container = null;਍ഀ
਍ഀ
    try਍ഀ
    {਍ഀ
        var control = null;਍ഀ
        var tryNS = false;਍ഀ
਍ഀ
        if (window.ActiveXObject)਍ഀ
        {਍ഀ
            try਍ഀ
            {਍ഀ
                control = new ActiveXObject('AgControl.AgControl');਍ഀ
                if (version === null)਍ഀ
                {਍ഀ
                    isVersionSupported = true;਍ഀ
                }਍ഀ
                else if (control.IsVersionSupported(version))਍ഀ
                {਍ഀ
                    isVersionSupported = true;਍ഀ
                }਍ഀ
                control = null;਍ഀ
            }਍ഀ
            catch (e)਍ഀ
            {਍ഀ
                tryNS = true;਍ഀ
            }਍ഀ
        }਍ഀ
        else਍ഀ
        {਍ഀ
            tryNS = true;਍ഀ
        }਍ഀ
        if (tryNS)਍ഀ
        {਍ഀ
            var plugin = navigator.plugins["Silverlight Plug-In"];਍ഀ
            if (plugin)਍ഀ
            {਍ഀ
                if (version === null)਍ഀ
                {਍ഀ
                    isVersionSupported = true;਍ഀ
                }਍ഀ
                else਍ഀ
                {਍ഀ
                    var actualVer = plugin.description;਍ഀ
                    if (actualVer === "1.0.30226.2")਍ഀ
                        actualVer = "2.0.30226.2";਍ഀ
                    var actualVerArray = actualVer.split(".");਍ഀ
                    while (actualVerArray.length > 3)਍ഀ
                    {਍ഀ
                        actualVerArray.pop();਍ഀ
                    }਍ഀ
                    while (actualVerArray.length < 4)਍ഀ
                    {਍ഀ
                        actualVerArray.push(0);਍ഀ
                    }਍ഀ
                    var reqVerArray = version.split(".");਍ഀ
                    while (reqVerArray.length > 4)਍ഀ
                    {਍ഀ
                        reqVerArray.pop();਍ഀ
                    }਍ഀ
਍ഀ
                    var requiredVersionPart;਍ഀ
                    var actualVersionPart;਍ഀ
                    var index = 0;਍ഀ
਍ഀ
਍ഀ
                    do਍ഀ
                    {਍ഀ
                        requiredVersionPart = parseInt(reqVerArray[index]);਍ഀ
                        actualVersionPart = parseInt(actualVerArray[index]);਍ഀ
                        index++;਍ഀ
                    }਍ഀ
                    while (index < reqVerArray.length && requiredVersionPart === actualVersionPart);਍ഀ
਍ഀ
                    if (requiredVersionPart <= actualVersionPart && !isNaN(requiredVersionPart))਍ഀ
                    {਍ഀ
                        isVersionSupported = true;਍ഀ
                    }਍ഀ
                }਍ഀ
            }਍ഀ
        }਍ഀ
    }਍ഀ
    catch (e)਍ഀ
    {਍ഀ
        isVersionSupported = false;਍ഀ
    }਍ഀ
    ਍ഀ
    return isVersionSupported;਍ഀ
};਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// WaitForInstallCompletion:਍ഀ
//਍ഀ
// Occasionally checks for Silverlight installation status. If it਍ഀ
// detects that Silverlight has been installed then it calls਍ഀ
// Silverlight.onSilverlightInstalled();. This is only supported਍ഀ
// if Silverlight was not previously installed on this computer.਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.WaitForInstallCompletion = function()਍ഀ
{਍ഀ
    if ( ! Silverlight.isBrowserRestartRequired && Silverlight.onSilverlightInstalled )਍ഀ
    {਍ഀ
        try਍ഀ
        {਍ഀ
            navigator.plugins.refresh();਍ഀ
        }਍ഀ
        catch(e)਍ഀ
        {਍ഀ
        }਍ഀ
        if (Silverlight.isInstalled(null) && !Silverlight.__onSilverlightInstalledCalled)਍ഀ
        {਍ഀ
            Silverlight.onSilverlightInstalled();਍ഀ
            Silverlight.__onSilverlightInstalledCalled = true;਍ഀ
        }਍ഀ
        else਍ഀ
        {਍ഀ
              setTimeout(Silverlight.WaitForInstallCompletion, 3000);਍ഀ
        }    ਍ഀ
    }਍ഀ
};਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// __startup:਍ഀ
//਍ഀ
// Performs startup tasks. ਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.__startup = function()਍ഀ
{਍ഀ
    navigator.plugins.refresh();਍ഀ
    Silverlight.isBrowserRestartRequired = Silverlight.isInstalled(null);਍ഀ
    if (!Silverlight.isBrowserRestartRequired)਍ഀ
    {਍ഀ
        Silverlight.WaitForInstallCompletion();਍ഀ
        if (!Silverlight.__installationEventFired)਍ഀ
        {਍ഀ
            Silverlight.onInstallRequired();਍ഀ
            Silverlight.__installationEventFired = true;਍ഀ
        }਍ഀ
    }਍ഀ
    else if (window.navigator.mimeTypes)਍ഀ
    {਍ഀ
        var mimeSL2 =   navigator.mimeTypes["application/x-silverlight-2"];਍ഀ
        var mimeSL2b2 = navigator.mimeTypes["application/x-silverlight-2-b2"];਍ഀ
        var mimeSL2b1 = navigator.mimeTypes["application/x-silverlight-2-b1"];਍ഀ
        var mimeHighestBeta = mimeSL2b1;਍ഀ
        if (mimeSL2b2)਍ഀ
            mimeHighestBeta = mimeSL2b2;਍ഀ
            ਍ഀ
        if (!mimeSL2 && (mimeSL2b1 || mimeSL2b2))਍ഀ
        {਍ഀ
            if (!Silverlight.__installationEventFired)਍ഀ
            {਍ഀ
                Silverlight.onUpgradeRequired();਍ഀ
                Silverlight.__installationEventFired = true;਍ഀ
            }਍ഀ
        }਍ഀ
        else if (mimeSL2 && mimeHighestBeta)਍ഀ
        {਍ഀ
            if (mimeSL2.enabledPlugin &&਍ഀ
                mimeHighestBeta.enabledPlugin)਍ഀ
            {਍ഀ
                if (mimeSL2.enabledPlugin.description !=਍ഀ
                    mimeHighestBeta.enabledPlugin.description)਍ഀ
                {਍ഀ
                    if (!Silverlight.__installationEventFired)਍ഀ
                    {਍ഀ
                        Silverlight.onRestartRequired();਍ഀ
                        Silverlight.__installationEventFired = true;਍ഀ
                    }਍ഀ
                }਍ഀ
            }਍ഀ
        }਍ഀ
    }਍ഀ
    if (!Silverlight.disableAutoStartup)਍ഀ
    {਍ഀ
        if (window.removeEventListener)਍ഀ
        {਍ഀ
            window.removeEventListener('load', Silverlight.__startup, false);਍ഀ
        }਍ഀ
        else਍ഀ
        {਍ഀ
            window.detachEvent('onload', Silverlight.__startup);਍ഀ
        }਍ഀ
    }਍ഀ
};਍ഀ
਍ഀ
///////////////////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// This block wires up Silverlight.__startup to be executed once the page਍ഀ
// loads. This is the desired behavior for most sites. If, however, a site਍ഀ
// prefers to control the timing of the Silverlight.__startup call then it should਍ഀ
// put the following block of javascript into the webpage before this file is਍ഀ
// included:਍ഀ
//਍ഀ
//    <script type="text/javascript">਍ഀ
//        if (!window.Silverlight)਍ഀ
//        {਍ഀ
//            window.Silverlight = {};਍ഀ
//        }਍ഀ
//        Silverlight.disableAutoStartup = true;਍ഀ
//    </script> ਍ഀ
//਍ഀ
/////////////////////////////////////////////////////////////////////////////////਍ഀ
਍ഀ
if (!Silverlight.disableAutoStartup)਍ഀ
{਍ഀ
    if (window.addEventListener)਍ഀ
    {਍ഀ
        window.addEventListener('load', Silverlight.__startup, false);਍ഀ
    }਍ഀ
    else਍ഀ
    {਍ഀ
        window.attachEvent('onload', Silverlight.__startup);਍ഀ
    }਍ഀ
}਍ഀ
਍ഀ
///////////////////////////////////////////////////////////////////////////////਍ഀ
// createObject:਍ഀ
//਍ഀ
// Inserts a Silverlight <object> tag or installation experience into the HTML਍ഀ
// DOM based on the current installed state of Silverlight. ਍ഀ
//਍ഀ
/////////////////////////////////////////////////////////////////////////////////਍ഀ
਍ഀ
Silverlight.createObject = function(source, parentElement, id, properties, events, initParams, userContext)਍ഀ
{਍ഀ
    var slPluginHelper = new Object();਍ഀ
    var slProperties = properties;਍ഀ
    var slEvents = events;਍ഀ
    ਍ഀ
    slPluginHelper.version = slProperties.version;਍ഀ
    slProperties.source = source;    ਍ഀ
    slPluginHelper.alt = slProperties.alt;਍ഀ
    ਍ഀ
    //rename properties to their tag property names. For bacwards compatibility਍ഀ
    //with Silverlight.js version 1.0਍ഀ
    if ( initParams )਍ഀ
        slProperties.initParams = initParams;਍ഀ
    if ( slProperties.isWindowless && !slProperties.windowless)਍ഀ
        slProperties.windowless = slProperties.isWindowless;਍ഀ
    if ( slProperties.framerate && !slProperties.maxFramerate)਍ഀ
        slProperties.maxFramerate = slProperties.framerate;਍ഀ
    if ( id && !slProperties.id)਍ഀ
        slProperties.id = id;਍ഀ
    ਍ഀ
    // remove elements which are not to be added to the instantiation tag਍ഀ
    delete slProperties.ignoreBrowserVer;਍ഀ
    delete slProperties.inplaceInstallPrompt;਍ഀ
    delete slProperties.version;਍ഀ
    delete slProperties.isWindowless;਍ഀ
    delete slProperties.framerate;਍ഀ
    delete slProperties.data;਍ഀ
    delete slProperties.src;਍ഀ
    delete slProperties.alt;਍ഀ
਍ഀ
਍ഀ
    // detect that the correct version of Silverlight is installed, else display install਍ഀ
਍ഀ
    if (Silverlight.isInstalled(slPluginHelper.version))਍ഀ
    {਍ഀ
        //move unknown events to the slProperties array਍ഀ
        for (var name in slEvents)਍ഀ
        {਍ഀ
            if ( slEvents[name])਍ഀ
            {਍ഀ
                if ( name == "onLoad" && typeof slEvents[name] == "function" && slEvents[name].length != 1 )਍ഀ
                {਍ഀ
                    var onLoadHandler = slEvents[name];਍ഀ
                    slEvents[name]=function (sender){ return onLoadHandler(document.getElementById(id), userContext, sender)};਍ഀ
                }਍ഀ
                var handlerName = Silverlight.__getHandlerName(slEvents[name]);਍ഀ
                if ( handlerName != null )਍ഀ
                {਍ഀ
                    slProperties[name] = handlerName;਍ഀ
                    slEvents[name] = null;਍ഀ
                }਍ഀ
                else਍ഀ
                {਍ഀ
                    throw "typeof events."+name+" must be 'function' or 'string'";਍ഀ
                }਍ഀ
            }਍ഀ
        }਍ഀ
        slPluginHTML = Silverlight.buildHTML(slProperties);਍ഀ
    }਍ഀ
    //The control could not be instantiated. Show the installation prompt਍ഀ
    else ਍ഀ
    {਍ഀ
        slPluginHTML = Silverlight.buildPromptHTML(slPluginHelper);਍ഀ
    }਍ഀ
਍ഀ
    // insert or return the HTML਍ഀ
    if(parentElement)਍ഀ
    {਍ഀ
        parentElement.innerHTML = slPluginHTML;਍ഀ
    }਍ഀ
    else਍ഀ
    {਍ഀ
        return slPluginHTML;਍ഀ
    }਍ഀ
਍ഀ
};਍ഀ
਍ഀ
///////////////////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
//  buildHTML:਍ഀ
//਍ഀ
//  create HTML that instantiates the control਍ഀ
//਍ഀ
///////////////////////////////////////////////////////////////////////////////਍ഀ
Silverlight.buildHTML = function( slProperties)਍ഀ
{਍ഀ
    var htmlBuilder = [];਍ഀ
਍ഀ
    htmlBuilder.push('<object type=\"application/x-silverlight\" data="data:application/x-silverlight,"');਍ഀ
    if ( slProperties.id != null )਍ഀ
    {਍ഀ
        htmlBuilder.push(' id="' + Silverlight.HtmlAttributeEncode(slProperties.id) + '"');਍ഀ
    }਍ഀ
    if ( slProperties.width != null )਍ഀ
    {਍ഀ
        htmlBuilder.push(' width="' + slProperties.width+ '"');਍ഀ
    }਍ഀ
    if ( slProperties.height != null )਍ഀ
    {਍ഀ
        htmlBuilder.push(' height="' + slProperties.height + '"');਍ഀ
    }਍ഀ
    htmlBuilder.push(' >');਍ഀ
    ਍ഀ
    delete slProperties.id;਍ഀ
    delete slProperties.width;਍ഀ
    delete slProperties.height;਍ഀ
    ਍ഀ
    for (var name in slProperties)਍ഀ
    {਍ഀ
        if (slProperties[name])਍ഀ
        {਍ഀ
            htmlBuilder.push('<param name="'+Silverlight.HtmlAttributeEncode(name)+'" value="'+Silverlight.HtmlAttributeEncode(slProperties[name])+'" />');਍ഀ
        }਍ഀ
    }਍ഀ
    htmlBuilder.push('<\/object>');਍ഀ
    return htmlBuilder.join('');਍ഀ
};਍ഀ
਍ഀ
਍ഀ
਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// createObjectEx:਍ഀ
//਍ഀ
// takes a single parameter of all createObject ਍ഀ
// parameters enclosed in {}਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
਍ഀ
Silverlight.createObjectEx = function(params)਍ഀ
{਍ഀ
    var parameters = params;਍ഀ
    var html = Silverlight.createObject(parameters.source, parameters.parentElement, parameters.id, parameters.properties, parameters.events, parameters.initParams, parameters.context);਍ഀ
    if (parameters.parentElement == null)਍ഀ
    {਍ഀ
        return html;਍ഀ
    }਍ഀ
};਍ഀ
਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// buildPromptHTML਍ഀ
//਍ഀ
// Builds the HTML to prompt the user to download and install Silverlight਍ഀ
//਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
Silverlight.buildPromptHTML = function(slPluginHelper)਍ഀ
{਍ഀ
    var slPluginHTML = "";਍ഀ
    var urlRoot = Silverlight.fwlinkRoot;਍ഀ
    var version = slPluginHelper.version ;਍ഀ
    if ( slPluginHelper.alt )਍ഀ
    {਍ഀ
        slPluginHTML = slPluginHelper.alt;਍ഀ
    }਍ഀ
    else਍ഀ
    {਍ഀ
        if (! version)਍ഀ
        {਍ഀ
            version="";਍ഀ
        }਍ഀ
        slPluginHTML = "<a href='javascript:Silverlight.getSilverlight(\"{1}\");' style='text-decoration: none;'><img src='{2}' alt='Get Microsoft Silverlight' style='border-style: none'/></a>";਍ഀ
        slPluginHTML = slPluginHTML.replace('{1}', version);਍ഀ
        slPluginHTML = slPluginHTML.replace('{2}', urlRoot + '108181');਍ഀ
    }਍ഀ
    ਍ഀ
    return slPluginHTML;਍ഀ
};਍ഀ
਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// getSilverlight:਍ഀ
//਍ഀ
// Navigates the browser to the appropriate Silverlight installer਍ഀ
//਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
Silverlight.getSilverlight = function(version)਍ഀ
{਍ഀ
    if (Silverlight.onGetSilverlight )਍ഀ
    {਍ഀ
        Silverlight.onGetSilverlight();਍ഀ
    }਍ഀ
    ਍ഀ
    var shortVer = "";਍ഀ
    var reqVerArray = String(version).split(".");਍ഀ
    if (reqVerArray.length > 1)਍ഀ
    {਍ഀ
        var majorNum = parseInt(reqVerArray[0] );਍ഀ
        if ( isNaN(majorNum) || majorNum < 2 )਍ഀ
        {਍ഀ
            shortVer = "1.0";਍ഀ
        }਍ഀ
        else਍ഀ
        {਍ഀ
            shortVer = reqVerArray[0]+'.'+reqVerArray[1];਍ഀ
        }਍ഀ
    }਍ഀ
    ਍ഀ
    var verArg = "";਍ഀ
    ਍ഀ
    if (shortVer.match(/^\d+\056\d+$/) )਍ഀ
    {਍ഀ
        verArg = "&v="+shortVer;਍ഀ
    }਍ഀ
    ਍ഀ
    Silverlight.followFWLink("114576" + verArg);਍ഀ
};਍ഀ
਍ഀ
਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// followFWLink:਍ഀ
//਍ഀ
// Navigates to a url based on fwlinkid਍ഀ
//਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
Silverlight.followFWLink = function(linkid)਍ഀ
{਍ഀ
    top.location=Silverlight.fwlinkRoot+String(linkid);਍ഀ
};਍ഀ
਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// HtmlAttributeEncode:਍ഀ
//਍ഀ
// Encodes special characters in input strings as charcodes਍ഀ
//਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
Silverlight.HtmlAttributeEncode = function( strInput )਍ഀ
{਍ഀ
      var c;਍ഀ
      var retVal = '';਍ഀ
਍ഀ
    if(strInput == null)਍ഀ
      {਍ഀ
          return null;਍ഀ
    }਍ഀ
      ਍ഀ
      for(var cnt = 0; cnt < strInput.length; cnt++)਍ഀ
      {਍ഀ
            c = strInput.charCodeAt(cnt);਍ഀ
਍ഀ
            if (( ( c > 96 ) && ( c < 123 ) ) ||਍ഀ
                  ( ( c > 64 ) && ( c < 91 ) ) ||਍ഀ
                  ( ( c > 43 ) && ( c < 58 ) && (c!=47)) ||਍ഀ
                  ( c == 95 ))਍ഀ
            {਍ഀ
                  retVal = retVal + String.fromCharCode(c);਍ഀ
            }਍ഀ
            else਍ഀ
            {਍ഀ
                  retVal = retVal + '&#' + c + ';';਍ഀ
            }਍ഀ
      }਍ഀ
      ਍ഀ
      return retVal;਍ഀ
};਍ഀ
///////////////////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
//  default_error_handler:਍ഀ
//਍ഀ
//  Default error handling function ਍ഀ
//਍ഀ
///////////////////////////////////////////////////////////////////////////////਍ഀ
਍ഀ
Silverlight.default_error_handler = function (sender, args)਍ഀ
{਍ഀ
    var iErrorCode;਍ഀ
    var errorType = args.ErrorType;਍ഀ
਍ഀ
    iErrorCode = args.ErrorCode;਍ഀ
਍ഀ
    var errMsg = "\nSilverlight error message     \n" ;਍ഀ
਍ഀ
    errMsg += "ErrorCode: "+ iErrorCode + "\n";਍ഀ
਍ഀ
਍ഀ
    errMsg += "ErrorType: " + errorType + "       \n";਍ഀ
    errMsg += "Message: " + args.ErrorMessage + "     \n";਍ഀ
਍ഀ
    if (errorType == "ParserError")਍ഀ
    {਍ഀ
        errMsg += "XamlFile: " + args.xamlFile + "     \n";਍ഀ
        errMsg += "Line: " + args.lineNumber + "     \n";਍ഀ
        errMsg += "Position: " + args.charPosition + "     \n";਍ഀ
    }਍ഀ
    else if (errorType == "RuntimeError")਍ഀ
    {਍ഀ
        if (args.lineNumber != 0)਍ഀ
        {਍ഀ
            errMsg += "Line: " + args.lineNumber + "     \n";਍ഀ
            errMsg += "Position: " +  args.charPosition + "     \n";਍ഀ
        }਍ഀ
        errMsg += "MethodName: " + args.methodName + "     \n";਍ഀ
    }਍ഀ
    alert (errMsg);਍ഀ
};਍ഀ
਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// __cleanup:਍ഀ
//਍ഀ
// Releases event handler resources when the page is unloaded਍ഀ
//਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
Silverlight.__cleanup = function ()਍ഀ
{਍ഀ
    for (var i = Silverlight._silverlightCount - 1; i >= 0; i--) {਍ഀ
        window['__slEvent' + i] = null;਍ഀ
    }਍ഀ
    Silverlight._silverlightCount = 0;਍ഀ
    if (window.removeEventListener) { ਍ഀ
       window.removeEventListener('unload', Silverlight.__cleanup , false);਍ഀ
    }਍ഀ
    else { ਍ഀ
        window.detachEvent('onunload', Silverlight.__cleanup );਍ഀ
    }਍ഀ
};਍ഀ
਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// __getHandlerName:਍ഀ
//਍ഀ
// Generates named event handlers for delegates.਍ഀ
//਍ഀ
///////////////////////////////////////////////////////////////////////////////////////////////਍ഀ
Silverlight.__getHandlerName = function (handler)਍ഀ
{਍ഀ
    var handlerName = "";਍ഀ
    if ( typeof handler == "string")਍ഀ
    {਍ഀ
        handlerName = handler;਍ഀ
    }਍ഀ
    else if ( typeof handler == "function" )਍ഀ
    {਍ഀ
        if (Silverlight._silverlightCount == 0)਍ഀ
        {਍ഀ
            if (window.addEventListener) ਍ഀ
            {਍ഀ
                window.addEventListener('onunload', Silverlight.__cleanup , false);਍ഀ
            }਍ഀ
            else ਍ഀ
            {਍ഀ
                window.attachEvent('onunload', Silverlight.__cleanup );਍ഀ
            }਍ഀ
        }਍ഀ
        var count = Silverlight._silverlightCount++;਍ഀ
        handlerName = "__slEvent"+count;਍ഀ
        ਍ഀ
        window[handlerName]=handler;਍ഀ
    }਍ഀ
    else਍ഀ
    {਍ഀ
        handlerName = null;਍ഀ
    }਍ഀ
    return handlerName;਍ഀ
};਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//  ਍ഀ
// onRequiredVersionAvailable:਍ഀ
//਍ഀ
// Called by version  verification control to notify the page that਍ഀ
// an appropriate build of Silverlight is available. The page ਍ഀ
// should respond by injecting the appropriate Silverlight control਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.onRequiredVersionAvailable = function() ਍ഀ
{਍ഀ
਍ഀ
};਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//  ਍ഀ
// onRestartRequired:਍ഀ
//਍ഀ
// Called by version verification control to notify the page that਍ഀ
// an appropriate build of Silverlight is installed but not loaded. ਍ഀ
// The page should respond by injecting a clear and visible ਍ഀ
// "Thanks for installing. Please restart your browser and return਍ഀ
// to mysite.com" or equivalent into the browser DOM਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.onRestartRequired = function() ਍ഀ
{਍ഀ
਍ഀ
};਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//  ਍ഀ
// onUpgradeRequired:਍ഀ
//਍ഀ
// Called by version verification control to notify the page that਍ഀ
// Silverlight must be upgraded. The page should respond by ਍ഀ
// injecting a clear, visible, and actionable upgrade message into਍ഀ
// the DOM. The message must inform the user that they need to ਍ഀ
// upgrade Silverlight to use the page. They are already somewhat਍ഀ
// familiar with the Silverlight product when they encounter this.਍ഀ
// Silverlight should be mentioned so the user expects to see that਍ഀ
// string in the installer UI. However, the Silverlight-powered਍ഀ
// application should be the focus of the solicitation. The user਍ഀ
// wants the app. Silverlight is a means to the app.਍ഀ
// ਍ഀ
// The upgrade solicitation will have a button that directs ਍ഀ
// the user to the Silverlight installer. Upon click the button਍ഀ
// should both kick off a download of the installer URL and replace਍ഀ
// the Upgrade text with "Thanks for downloading. When the upgarde਍ഀ
// is complete please restart your browser and return to ਍ഀ
// mysite.com" or equivalent.਍ഀ
//਍ഀ
// Note: For a more interesting upgrade UX we can use Silverlight਍ഀ
// 1.0-style XAML for this upgrade experience. Contact PiotrP for਍ഀ
// details.਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.onUpgradeRequired = function() ਍ഀ
{਍ഀ
਍ഀ
};਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//  ਍ഀ
// onInstallRequired:਍ഀ
//਍ഀ
// Called by Silverlight.checkInstallStatus to notify the page਍ഀ
// that Silverlight has not been installed by this user.਍ഀ
// The page should respond by ਍ഀ
// injecting a clear, visible, and actionable upgrade message into਍ഀ
// the DOM. The message must inform the user that they need to ਍ഀ
// download and install components needed to use the page. ਍ഀ
// Silverlight should be mentioned so the user expects to see that਍ഀ
// string in the installer UI. However, the Silverlight-powered਍ഀ
// application should be the focus of the solicitation. The user਍ഀ
// wants the app. Silverlight is a means to the app.਍ഀ
// ਍ഀ
// The installation solicitation will have a button that directs ਍ഀ
// the user to the Silverlight installer. Upon click the button਍ഀ
// should both kick off a download of the installer URL and replace਍ഀ
// the Upgrade text with "Thanks for downloading. When installation਍ഀ
// is complete you may need to refresh the page to view this ਍ഀ
// content" or equivalent.਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.onInstallRequired = function() ਍ഀ
{਍ഀ
਍ഀ
};਍ഀ
਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//  ਍ഀ
// IsVersionAvailableOnError:਍ഀ
//਍ഀ
// This function should be called at the beginning of a web page's਍ഀ
// Silverlight error handler. It will determine if the required ਍ഀ
// version of Silverlight is installed and available in the ਍ഀ
// current process.਍ഀ
//਍ഀ
// During its execution the function will trigger one of the ਍ഀ
// Silverlight installation state events, if appropriate.਍ഀ
//਍ഀ
// Sender and Args should be passed through from  the calling਍ഀ
// onError handler's parameters. ਍ഀ
//਍ഀ
// The associated Sivlerlight <object> tag must have਍ഀ
// minRuntimeVersion set and should have autoUpgrade set to false.਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.IsVersionAvailableOnError = function(sender, args)਍ഀ
{਍ഀ
    var retVal = false;਍ഀ
    try਍ഀ
    {਍ഀ
        if (args.ErrorCode == 8001 && !Silverlight.__installationEventFired)਍ഀ
        {਍ഀ
            Silverlight.onUpgradeRequired();਍ഀ
            Silverlight.__installationEventFired = true;਍ഀ
        }਍ഀ
        else if (args.ErrorCode == 8002 && !Silverlight.__installationEventFired)਍ഀ
        {਍ഀ
            Silverlight.onRestartRequired();਍ഀ
            Silverlight.__installationEventFired = true;਍ഀ
        }਍ഀ
        // this handles upgrades from 1.0. That control did not਍ഀ
        // understand the minRuntimeVerison parameter. It also਍ഀ
        // did not know how to parse XAP files, so would throw਍ഀ
        // Parse Error (5014). A Beta 2 control may throw 2106਍ഀ
        else if (args.ErrorCode == 5014 || args.ErrorCode == 2106)਍ഀ
        {਍ഀ
            if (Silverlight.__verifySilverlight2UpgradeSuccess(args.getHost()))਍ഀ
            {਍ഀ
                retVal = true;਍ഀ
            }਍ഀ
        }਍ഀ
        else਍ഀ
        {਍ഀ
            retVal = true;਍ഀ
        }਍ഀ
    }਍ഀ
    catch (e)਍ഀ
    {਍ഀ
    }਍ഀ
    return retVal;਍ഀ
};਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//  ਍ഀ
// IsVersionAvailableOnLoad:਍ഀ
//਍ഀ
// This function should be called at the beginning of a web page's਍ഀ
// Silverlight onLoad handler. It will determine if the required ਍ഀ
// version of Silverlight is installed and available in the ਍ഀ
// current process.਍ഀ
//਍ഀ
// During its execution the function will trigger one of the ਍ഀ
// Silverlight installation state events, if appropriate.਍ഀ
//਍ഀ
// Sender should be passed through from  the calling਍ഀ
// onError handler's parameters. ਍ഀ
//਍ഀ
// The associated Sivlerlight <object> tag must have਍ഀ
// minRuntimeVersion set and should have autoUpgrade set to false.਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.IsVersionAvailableOnLoad = function(sender)਍ഀ
{਍ഀ
    var retVal = false;਍ഀ
    try਍ഀ
    {਍ഀ
        if (Silverlight.__verifySilverlight2UpgradeSuccess(sender.getHost()))਍ഀ
        {਍ഀ
            retVal = true;਍ഀ
        }਍ഀ
    }਍ഀ
    catch (e)਍ഀ
    {਍ഀ
    }਍ഀ
    return retVal;਍ഀ
};਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
//਍ഀ
// __verifySilverlight2UpgradeSuccess:਍ഀ
//਍ഀ
// This internal function helps identify installation state by਍ഀ
// taking advantage of behavioral differences between the਍ഀ
// 1.0 and 2.0 releases of Silverlight. ਍ഀ
//਍ഀ
//////////////////////////////////////////////////////////////////਍ഀ
Silverlight.__verifySilverlight2UpgradeSuccess = function(host)਍ഀ
{਍ഀ
    var retVal = false;਍ഀ
    var version = "2.0.31005";਍ഀ
    var installationEvent = null;਍ഀ
਍ഀ
    try਍ഀ
    {਍ഀ
        if (host.IsVersionSupported(version + ".99"))਍ഀ
        {਍ഀ
            installationEvent = Silverlight.onRequiredVersionAvailable;਍ഀ
            retVal = true;਍ഀ
        }਍ഀ
        else if (host.IsVersionSupported(version + ".0"))਍ഀ
        {਍ഀ
            installationEvent = Silverlight.onRestartRequired;਍ഀ
        }਍ഀ
        else਍ഀ
        {਍ഀ
            installationEvent = Silverlight.onUpgradeRequired;਍ഀ
        }਍ഀ
਍ഀ
        if (installationEvent && !Silverlight.__installationEventFired)਍ഀ
        {਍ഀ
            installationEvent();਍ഀ
            Silverlight.__installationEventFired = true;਍ഀ
        }਍ഀ
    }਍ഀ
    catch (e)਍ഀ
    {਍ഀ
    }਍ഀ
    return retVal;਍ഀ
};਍ഀ