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

//

//  SILF.js - Silverlight Install and Logger Framework		version 3.0.50616.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://msdn.microsoft.com/en-us/cc300389.aspx#MLPL.  

//  You may not use or distribute this file or the code in this file except as 

//  expressly permitted under that license.

// 

//	This code contains functionality from silverlight.js, 

//	silverlightSupportedUserAgent.js, silverlightVersion.js which are also MSPL licensed

//

//	This code uses functionality from math.uuid.js http://www.broofa.com/Tools/Math.uuid.js

//	See appropriate comments below for more information

//

//  Copyright (c) Microsoft Corporation. All rights reserved.

//

///////////////////////////////////////////////////////////////////////////////



if (!window.Silverlight)

{ 

    window.Silverlight = { };

    Silverlight.disableAutoStartup = true;

	Silverlight.ua = null;

}



//////////////////////////////////////////////////////////////////

//

// _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 backwards 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("149156" + 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('unload', 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 = SILF.minSlVersion.split(".")[0] + "." + SILF.minSlVersion.split(".")[1] + "." + SILF.minSlVersion.split(".")[2]; 

    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;

};



Silverlight.detectSilverlightVersion = function() {

	var container = null;

	var silverlightVersion;



	try {

		var control = null;



		try {

			control = new ActiveXObject('AgControl.AgControl');

		}

		catch (z) {

			if ( navigator.plugins["Silverlight Plug-In"] )

			{

				container = document.createElement('div');

				document.body.appendChild(container);

				container.innerHTML= '<embed type="application/x-silverlight" />';

				control = container.childNodes[0];

			}

		}		

		if (control.Settings) {

			try {

				silverlightVersion = control.Settings.version;

			}

			catch (z) {

			}

		}

// Use hard-coded version numbers to test installed version

// ToDo: make this a web lookup for latest version number list

		var slVers=new Array(

			"4.0.50303.0",	// 4 RC

			"4.0.41108.0",  // 4 Beta 1 

			"3.0.50106.0",  // 3 GDR 3

			"3.0.40818.0",  // 3 GDR 2

			"3.0.40723.0",  // 3 GDR 1

			"3.0.40624.0",	// 3 RTW

			"3.0.40307.0",

			"2.0.40115.0",

			"2.0.31005.0",

			"2.0.30523.9",

			"2.0.30523.8",

			"2.0.30523.6",

			"2.0.30226.2",

			"1.0.30715.0",

			"1.0.30401.0",

			"1.0.30109.0",

			"1.0.21115.0",

			"1.1.20926.0",

			"1.0.20816"

			);

		if (!silverlightVersion) {

			for (i in slVers) {

				if (control.IsVersionSupported(slVers[i])) {

					silverlightVersion = slVers[i];

					break;

				} 

			}

		}

// If it falls through the hard-coded test then itterate through possible version numbers		

		if (!silverlightVersion)

		{

			var major = 0;

			var minor = 0;

			var revision = 0;

			var build = 0;

			

			var buildVersionString = function(versionNumbers) {

				var versionString = "";

				for (var l = 0; l < versionNumbers.length; ++l) {

					versionString += versionNumbers[l];

					if (l != versionNumbers.length - 1)

						versionString += ".";

				}

				return versionString;

			}

			

			var versionNumbers = [0,0,0,0];

			for(var i = 0; i < versionNumbers.length; ++i) {

				for (var incrementor = 0; incrementor < 100000; ++incrementor) {

					versionNumbers[i] = incrementor;



					if (!control.IsVersionSupported(buildVersionString(versionNumbers))) {

						versionNumbers[i] = incrementor - 1;

						break;

					} 

				}

			}

			

			silverlightVersion = buildVersionString(versionNumbers);

		}





		control = null; 

	}

	catch (e) {

	}

	if (container) {

		document.body.removeChild(container);

	}

	

	if (!silverlightVersion)

		silverlightVersion = "Not installed!";

	

	return silverlightVersion;

}



// Installation and Logger code



if (!window.SILF)

	window.SILF = {};



SILF.logCount = 0;



SILF.appName = "";

SILF.appVersion = "";

SILF.logEntryflow = false;  // log the entryflow (installed / current / supported)

SILF.logInstall = false;  // log the install experience

SILF.loggingURIentry = ""; // logging URI for entryflow may be different for testing/production, if blank no logging

SILF.loggingURIinstall = ""; // logging URI for install may be different for testing/production, if blank no logging

SILF.minSlVersion = "3.0.50106.0"; // Required Silverlight version

SILF.SilverlightControlHost = ""; // div which contains Silverlight control



SILF.PromptInstall = "Please <a href='#' onclick='SILF.InstallClicked()'>click here to install Silverlight</a>";

SILF.PromptFinishInstall = "Please wait for Silverlight installation to complete. You may need to refresh the page.";

SILF.PromptUpgrade = "Please <a href='#' onclick='SILF.UpgradeClicked()'>click here to upgrade Silverlight</a>";

SILF.PromptFinishUpgrade = "Please wait for Silverlight upgrade to complete. You will need to restart your browser.";

SILF.PromptRestart = "Please exit/quit and restart your browser to proceed";

SILF.PromptNotSupported = "Sorry, your browser or operating system are not supported";

SILF.RedirectNotSupported = "";



SILF.statusShowInstall = 1; // install screen shown to user

SILF.statusShowUpgrade = 2; // upgrade screen show to user

SILF.statusShowUnsupported = 3; // unsupported platform shown to user (eg PPC Mac)

SILF.statusShowRestart = 4; // Show "restart required" after upgrade

SILF.statusChooseInstall = 5; // user chose to install

SILF.statusChooseUpgrade = 6; // user chose to upgrade

SILF.statusChooseReject = 7; // user selected a "no thanks" option

SILF.statusChooseAbandon = 8; // user abandoned (navigate away / close browser)



SILF.statusSuccess = 10; // successful installation



// deployment settings

SILF.loggingDelay = 1250;	// used to allow logging call to complete if browser closed

SILF.ErrorHandler = function(source, error) { alert("Oops! An unexpected error occurred.\n\nSource: " + source + "\nDescription: " + error.description); };



SILF.entryFlowCookieName = function() {

	return SILF.appName + "entryFlow";

}



SILF.appIdCookieName = function() {

	return SILF.appName + "appId";

}



SILF.installFlowCookieName = function() {

	return SILF.appName + "installFlow";

}



// common functions

SILF.getClientState = function() {

	if (!SILF.clientState) {

		var o = {};

		o.uid = SILF.getUid();

		o.isLogEntryFlowCookieDefined = SILF.isCookieDefined(SILF.entryFlowCookieName(), "1");

		o.isLogInstallFlowCookieDefined = SILF.isCookieDefined(SILF.installFlowCookieName(), "2");

		o.isSlVersionInstalled = Silverlight.isInstalled(SILF.minSlVersion);

		o.isSlVersionSupported = Silverlight.supportedUserAgent(SILF.minSlVersion.substring(0, 1).concat(".0"));

		o.isSlUpgradeRequired = !o.isSlVersionInstalled && Silverlight.isInstalled(null);

		SILF.clientState = o;

	}



	return SILF.clientState;

};



SILF.onPlayerPageBeforeUnload = function() {

	// log abandoned install on badge

	if (SILF.installState == SILF.statusShowInstall || SILF.installState == SILF.statusShowUpgrade) {

		SILF.logInstallFlow(SILF.statusChooseAbandon);

	}



	// force delay to allow logging to complete

	var date = new Date();

	while (new Date() - date < SILF.loggingDelay) {}

};





SILF.isCookieDefined = function(name, value) {

	var cookieValue = SILF.getCookieValue(name);

	return SILF.equals(cookieValue, value);

};



SILF.getCookieValue = function(name, caseSensitive) {

	var cookie = document.cookie;



	if (cookie && cookie.length > 0) {

		var items = cookie.split(";");

		return SILF.getParamValue(items, name, caseSensitive);

	}

};



SILF.getParamValue = function(items, name, caseSensitive) {

	for (i = 0; i < items.length; i++) {

		var item = items[i].split("=");



		if (SILF.equals(SILF.trim(unescape(item[0])), name, caseSensitive))

			return item[1] ? unescape(item[1]) : item[1];

	}

};



SILF.equals = function(s1, s2, caseSensitive) {

	if (s1 == s2)

		return true;

	else if (s1 == null || s2 == null || caseSensitive)

		return false;

	else

		return s1.toLowerCase() == s2.toLowerCase();

};



SILF.trim = function(s) {

	return s.replace(/^\s+|\s+$/g, "");

};



SILF.setCookie = function(name, value, hours) {

	if (hours) {

		var expDate = new Date(new Date().getTime() + hours * 60 * 60 * 1000);

		document.cookie = name + "=" + value + ";expires=" + expDate.toGMTString();

	}

	else {

		document.cookie = name + "=" + value;

	}

};



SILF.clearCookie = function(name) {

	document.cookie = name + "=;expires=Thu, 01-Jan-1970 00:00:01 GMT";

};



SILF.getUid = function() {

	var uid = SILF.getCookieValue(SILF.appIdCookieName());



	if (!uid) {

		uid = Math.uuid();

		SILF.setCookie(SILF.appIdCookieName(), uid);

	}



	return uid;

};



SILF.getParamValue = function(items, name, caseSensitive) {

	for (i = 0; i < items.length; i++) {

		var item = items[i].split("=");



		if (SILF.equals(SILF.trim(unescape(item[0])), name, caseSensitive))

			return item[1] ? unescape(item[1]) : item[1];

	}

};



SILF.appendScript = function(index, src) {

	try {

		var script = document.createElement("script");

		script.id = "script" + index;

		script.src = src;

		script.type = "text/javascript";



		var head = document.getElementsByTagName("head")[0];

		head.appendChild(script);

	}

	catch (e) {

		SILF.ErrorHandler("SILF.appendScript", e);

	}

};



SILF.removeScript = function(index) {

	try {

		var script = document.getElementById("script" + index);

		var head = document.getElementsByTagName("head")[0];

		head.removeChild(script);

	}

	catch (e) {

		SILF.ErrorHandler("SILF.removeScript", e);

	}

};



SILF.logEntryFlow = function() {

	try {

		var state = SILF.getClientState();



		if (!state.isLogEntryFlowCookieDefined) {

			// set the session cookie to avoid multiple calls

			SILF.setCookie(SILF.entryFlowCookieName(), "1");



			if (SILF.logEntryflow && SILF.loggingURIentry != "") {

				// service parameters

				var sls, sle, p;

				var u = state.uid;

				var r = encodeURIComponent(document.referrer);

				var i = SILF.logCount++;

				var t = new Date().getTime();



				// Silverlight install state

				if (state.isSlVersionInstalled)

					sls = 2;

				else if (state.isSlUpgradeRequired)

					sls = 1;

				else

					sls = 0;



				// Silverlight support state

				if (state.isSlVersionSupported)

					sle = 1;

				else if (SILF.Browser == "Chrome" && SILF.OperatingSystem == "Windows")

					sle = 1;	// treating this as a fully supported platform

				else

					sle = 0;

					

				// append script tag

				var src = SILF.queryTest(SILF.loggingURIentry) + "u=" + u + "&s=" + sls + "&o=" + sle + "&i=" + i + '&t=' + t + '&an=' + SILF.appName + '&av=' + SILF.appVersion + '&r=' +r;

				

				SILF.appendScript(i, src);

			}

		}

	}

	catch (e) {

		SILF.ErrorHandler("SILF.logEntryFlow", e);

	}

};



SILF.logInstallFlow = function(action) {

	SILF.installState = action;

	try {

		// attempting to run silverlight install

		if (action == SILF.statusChooseInstall || action == SILF.statusChooseUpgrade)

			SILF.setCookie(SILF.installFlowCookieName(), "2", 1);

		// install success

		else if (action == SILF.statusSuccess || action == SILF.statusChooseReject || action == SILF.statusChooseAbandon)

			SILF.clearCookie(SILF.installFlowCookieName());



		var state = SILF.getClientState();



		// make the uid stick around for up to 24 hours if we're in an install cycle

		if (action == SILF.statusChooseReject || action == SILF.statusChooseAbandon) {

		} else {

			SILF.setCookie(SILF.appIdCookieName(), state.uid,24);

		}

		if (SILF.logInstall && SILF.loggingURIinstall != "") {

			// svc parameters

			var u = state.uid;

			var a = action;

			var i = SILF.logCount++;

			var t = new Date().getTime();



			// append script tag

			var src = SILF.queryTest(SILF.loggingURIinstall) + "u=" + u + "&a=" + a + "&i=" + i + '&t=' + t + '&an=' + SILF.appName + '&av=' + SILF.appVersion;



			SILF.appendScript(i, src);

		}

	}

	catch (e) {

		SILF.ErrorHandler("SILF.logInstallFlow", e);

	}

};



SILF.queryTest = function(testURI) {

// if the URI contains a ? already then we need to & our parameters, else add them as a ?

	var ret = "?";

	if (testURI.indexOf("?") > 0) {

		ret = "&";

	}

	return testURI + ret;

}



SILF.onLauncherPageLoad = function() {

// if the object we're tracking exists on the page

// initialize the scripts

// otherwise just exit

	if (document.getElementById(SILF.SilverlightControlHost)) {



		// ensure that if browser is closed/page left it gets tracked

		window.onbeforeunload = SILF.onPlayerPageBeforeUnload;



		// determine Browser and OS and supported platform status

		SILF.supportedUserAgent = Silverlight.supportedUserAgent(SILF.minSlVersion.split(".")[0] + "." + SILF.minSlVersion.split(".")[1]);

		

		SILF.logEntryFlow();



		// Perform the normal SIlverlight startup routine that would have happened in Silverlight.js

		Silverlight.__startup()

	}

} 



// Note this is not in the SILF or Silverlight namespace as the object load parameter does not allow periods

function onSilverlightError(sender, args) {

	// 8001 code for upgrade required

	// 8002 code for restart required

	// 5014 code for improper installation (also fires if sl1.0 is installed)

	if ((args.ErrorCode == 8001) || (args.ErrorCode == 5014)) {

	// ignore as should be captured via silverlight.js events

	} else if (args.ErrorCode == 8002) {

		Silverlight.onRestartRequired()

	} else {

		alert("Debug:  Error Code = " + args.ErrorCode);

	}

}



// Note this is not in the SILF or Silverlight namespace as the object load parameter does not allow periods

function onSilverlightLoad(sender) {



	Silverlight.IsVersionAvailableOnLoad(sender);



	var state = SILF.getClientState();



	if (state.isSlVersionInstalled) {

		// log successful install

		if (state.isLogInstallFlowCookieDefined) {

			SILF.logInstallFlow(SILF.statusSuccess);

		}

	}

}



SILF.showSlate = function(slate) {

	document.getElementById(SILF.SilverlightControlHost).innerHTML = slate

}



Silverlight.onRestartRequired = function() {

	SILF.logInstallFlow(SILF.statusShowRestart);

	SILF.showSlate(SILF.PromptRestart);

};



Silverlight.onUpgradeRequired = function() {

	SILF.logInstallFlow(SILF.statusShowUpgrade);

	if (SILF.CheckSupported(SILF.PromptUpgrade)) {

	}

};



Silverlight.onInstallRequired = function() {

	SILF.logInstallFlow(SILF.statusShowInstall);

	if (SILF.CheckSupported(SILF.PromptInstall)) {

	}

};



SILF.UpgradeClicked = function() {

	SILF.logInstallFlow(SILF.statusChooseUpgrade);

	SILF.showSlate(SILF.PromptFinishUpgrade);

	// if user has Chrome on Windows link directly to exe (currently SL3 handler reports unknown platform but we handle the message via slate)

	if (SILF.Browser == "Chrome" && SILF.OperatingSystem == "Windows") {

		Silverlight.followFWLink("156091");

	} else {

		Silverlight.followFWLink("149156&v=" + SILF.minSlVersion);

	}

}



SILF.InstallClicked = function() {

	SILF.logInstallFlow(SILF.statusChooseInstall);

	SILF.showSlate(SILF.PromptFinishInstall);

	// if user has Chrome on Windows link directly to exe (currently SL3 handler reports unknown platform but we handle the message via slate)

	if (SILF.Browser == "Chrome" && SILF.OperatingSystem == "Windows") {

		Silverlight.followFWLink("156091");

	} else {

		Silverlight.followFWLink("149156&v=" + SILF.minSlVersion);

	}

}



SILF.CheckSupported = function(msg) {

// check to ensure current version is supported (tests the 3.0 for instance)

var supported = SILF.supportedUserAgent;



	if (parseInt(SILF.minSlVersion.split(".")[0]) < 4 && SILF.Browser == "Chrome" && SILF.OperatingSystem == "Windows") {

		// If Chrome and SL < 4 might want to alert users

		if ((typeof(SILF.PromptNotTested) != "undefined") && (SILF.PromptNotTested != "")) {

			msg = msg.replace(/<!--warn-->/i, SILF.PromptNotTested);

		}

	}

	if (supported) {

		SILF.showSlate(msg);

	 

		if (parseInt(SILF.minSlVersion.split(".")[0]) < 4 && SILF.Browser == "Chrome" && SILF.OperatingSystem == "Windows") {

		// alert that Chrome isn't fully tested for SL < 4

			if ((typeof(SILF.WarningNotTested) != "undefined") && (SILF.WarningNotTested != "")) {

				alert(SILF.WarningNotTested);

			}

		}

		return(true);

	} else {

		SILF.logInstallFlow(SILF.statusShowUnsupported);

		if (SILF.RedirectNotSupported != "") {

			window.location = SILF.RedirectNotSupported;

		} else {

			SILF.showSlate(SILF.PromptNotSupported);

		}

		return(false);

	}

}



////

// Based on original Silverlight.supportedUserAgent but extended to expose

// OS and Browser and also manage SL version 3.0 and 4.0

////

SILF.OperatingSystem = "";

SILF.Browser = "";



///////////////////////////////////////////////////////////////////////////////

//

// supportedUserAgent:

//

// NOTE: This function is strongly tied to current implementations of web 

// browsers. The implementation of this function will change over time to 

// account for new Web browser developments. Visit 

// http://code.msdn.microsoft.com/SLsupportedUA often to ensure that you have

// the latest version.

//

// Determines if the client browser is supported by Silverlight. 

//

//  params:

//   version [string] 

//         determines if a particular version of Silverlight supports

//         this browser. Acceptable values are "1.0" and "2.0" etc

//   userAgent [string]

//         optional. User Agent string to be analyzed. If null then the

//         current browsers user agent string will be used.

//

//  return value: boolean

//

///////////////////////////////////////////////////////////////////////////////

Silverlight.supportedUserAgent = function(version, userAgent) {

	try {

		var ua = null;



		if (userAgent) {

			ua = userAgent;

		}

		else {

			ua = window.navigator.userAgent;

		}



		var slua = { OS: 'Unsupported', Browser: 'Unsupported' };



		v = SILF.parseVersion(version);

		

		//Silverlight does not support pre-Windows NT platforms

		if (ua.indexOf('Windows NT') >= 0 || ua.indexOf('Mozilla/4.0 (compatible; MSIE 6.0)') >= 0) {

			slua.OS = 'Windows';

		}

		else if (ua.indexOf('PPC Mac OS X') >= 0) {

			slua.OS = 'MacPPC';

		}

		else if (ua.indexOf('Intel Mac OS X') >= 0) {

			slua.OS = 'MacIntel';

		}

		else if (ua.indexOf('Linux') >= 0) {

			slua.OS = 'Linux';

		}



		SILF.OperatingSystem = slua.OS;



		if (slua.OS != 'Unsupported') {

			if (ua.indexOf('MSIE') >= 0) {

				if (navigator.userAgent.indexOf('Win64') == -1) {

					if (parseInt(ua.split('MSIE')[1]) >= 6) {

						slua.Browser = 'MSIE';

					}

				}

			}

			else if (ua.indexOf('Firefox') >= 0) {

				var versionArr = ua.split('Firefox/')[1].split('.');

				var major = parseInt(versionArr[0]);

				if (major >= 2) {

					slua.Browser = 'Firefox';

				}

				else {

					var minor = parseInt(versionArr[1]);

					if ((major == 1) && (minor >= 5)) {

						slua.Browser = 'Firefox';

					}

				}

			}



			else if (ua.indexOf('Chrome') >= 0) {

				slua.Browser = 'Chrome';

			}



			else if (ua.indexOf('Safari') >= 0) {

				slua.Browser = 'Safari';

			}



		}

		SILF.Browser = slua.Browser;

		return !(

			(slua.OS == "Unsupported") ||

			(slua.OS == "Linux" && v < 3) ||

			(slua.OS == "MacPPC" && v > 1) ||

			(slua.OS == "MacPPC" && slua.Browser == "MSIE") ||

			(slua.OS == "MacIntel" && slua.Browser == "MSIE") ||

			(slua.OS == "Windows" && slua.Browser == "Safari") ||

			(slua.Browser == "Unsupported") ||

			(ua.indexOf("Windows NT 5.0") >= 0 && v < 2) ||

			(slua.OS == "Windows" && slua.Browser == "Chrome" && v < 3)

			);

	}

	catch (e) {

		return false;

	}

}



SILF.parseVersion = function(value)

{

	try

	{

		if (value)

		{

			var array = value.split(".");



			if (array.length > 1)

			{

				var major = parseInt(array[0]);



				if (isNaN(major) || major < 2)

					return 1;

				else

					return parseFloat(array[0] + "." + array[1]);

			}

		}



		return NaN;

	}

	catch (x)

	{

		SILF.handleError("SIFL.parseVersion", x);

	}

};



/*

File: Math.uuid.js

Version: 1.4

Change History:

  v1.0 - first release

  v1.1 - less code and 2x performance boost (by minimizing calls to Math.random())

  v1.2 - Add support for generating non-standard uuids of arbitrary length

  v1.3 - Fixed IE7 bug (can't use []'s to access string chars.  Thanks, Brian R.)

  v1.4 - Changed method to be "Math.uuid". Added support for radix argument.  Use module pattern for better encapsulation.



Latest version:   http://www.broofa.com/Tools/Math.uuid.js

Information:      http://www.broofa.com/blog/?p=151

Contact:          robert@broofa.com

----

Copyright (c) 2008, Robert Kieffer

All rights reserved.



Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:



    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

    * Neither the name of Robert Kieffer nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.



THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/



Math.uuid=(function(){var h='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');return function(f,c){var d=h,a=[],g=Math.random;c=c||d.length;if(f){for(var b=0;b<f;b++)a[b]=d[0|g()*c]}else{var e;a[8]=a[13]=a[18]=a[23]='-';a[14]='4';for(var b=0;b<36;b++){if(!a[b]){e=0|g()*16;a[b]=d[(b==19)?(e&0x3)|0x8:e&0xf]}}}return a.join('').toLowerCase()}})();