ÿþ///////////////////////////////////////////////////////////////////////////////

//

//  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;

};