892 lines
28 KiB
JavaScript
892 lines
28 KiB
JavaScript
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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;
|
|
};
|