From c80a22f026af465bee8bc88fd7058693c327e216 Mon Sep 17 00:00:00 2001 From: Pacien TRAN-GIRARD Date: Sat, 22 Feb 2014 18:57:47 +0100 Subject: Embed applet in the website --- website/assets/js/deployJava.js | 1305 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 1305 insertions(+) create mode 100644 website/assets/js/deployJava.js (limited to 'website/assets/js/deployJava.js') diff --git a/website/assets/js/deployJava.js b/website/assets/js/deployJava.js new file mode 100644 index 0000000..879df1c --- /dev/null +++ b/website/assets/js/deployJava.js @@ -0,0 +1,1305 @@ +/* + * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved. + * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. + * + * 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 Oracle 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. + */ + +/* + * deployJava.js + * + * This file is part of the Deployment Toolkit. It provides functions for web + * pages to detect the presence of a JRE, install the latest JRE, and easily run + * applets or Web Start programs. More Information on usage of the + * Deployment Toolkit can be found in the Deployment Guide at: + * http://docs.oracle.com/javase/6/docs/technotes/guides/jweb/index.html + * + * The "live" copy of this file may be found at : + * http://java.com/js/deployJava.js. + * For web pages provisioned using https, you may want to access the copy at: + * https://java.com/js/deployJava.js. + * + * You are encouraged to link directly to the live copies. + * The above files are stripped of comments and whitespace for performance, + * You can access this file w/o the whitespace and comments removed at: + * http://java.com/js/deployJava.txt. + * + */ + +var deployJava = function() { + /** HTML attribute filter implementation */ + var hattrs = { + core: [ 'id', 'class', 'title', 'style' ], + i18n: [ 'lang', 'dir' ], + events: [ 'onclick', 'ondblclick', 'onmousedown', 'onmouseup', + 'onmouseover', 'onmousemove', 'onmouseout', 'onkeypress', + 'onkeydown', 'onkeyup' ], + applet: [ 'codebase', 'code', 'name', 'archive', 'object', + 'width', 'height', 'alt', 'align', 'hspace', 'vspace' ], + object: [ 'classid', 'codebase', 'codetype', 'data', 'type', + 'archive', 'declare', 'standby', 'height', 'width', 'usemap', + 'name', 'tabindex', 'align', 'border', 'hspace', 'vspace' ] + }; + + var object_valid_attrs = hattrs.object.concat(hattrs.core, hattrs.i18n, + hattrs.events); + var applet_valid_attrs = hattrs.applet.concat(hattrs.core); + + // generic log function, use console.log unless it isn't available + // then revert to alert() + function log(message) { + if ( ! rv.debug ) {return}; + + if (console.log) { + console.log(message); + } else { + alert(message); + } + } + + //checks where given version string matches query + // + //NB: assume format is correct. Can add format check later if needed + // from dtjava.js + function versionCheckEx(query, version) { + if (query == null || query.length == 0) return true; + + var c = query.charAt(query.length - 1); + + //if it is not explicit pattern but does not have update version then need to append * + if (c != '+' && c != '*' && (query.indexOf('_') != -1 && c != '_')) { + query = query + "*"; + c = '*'; + } + + query = query.substring(0, query.length - 1); + //if query ends with ".", "_" then we want to strip it to allow match of "1.6.*" to shorter form such as "1.6" + //TODO: add support for match of "1.7.0*" to "1.7"? + if (query.length > 0) { + var z = query.charAt(query.length - 1); + if (z == '.' || z == '_') { + query = query.substring(0, query.length - 1); + } + } + if (c == '*') { + //it is match if version starts from it + return (version.indexOf(query) == 0); + } else if (c == '+') { + //match if query string is lexicographically smaller + return query <= version; + } + return false; + } + + function getWebStartLaunchIconURL() { + var imageUrl = '//java.com/js/webstart.png'; + try { + // for http/https; use protocol less url; use http for all other protocol + return document.location.protocol.indexOf('http') != -1 ? + imageUrl : 'http:' + imageUrl; + } catch (err) { + return 'http:' + imageUrl; + } + } + + // GetJava page + function constructGetJavaURL(query) { + + var getJavaURL = 'http://java.com/dt-redirect'; + + if (query == null || query.length == 0) return getJavaURL; + if(query.charAt(0) == '&') + { + query = query.substring(1, query.length); + } + return getJavaURL + '?'+ query; + } + + function arHas(ar, attr) { + var len = ar.length; + for (var i = 0; i < len; i++) { + if (ar[i] === attr) return true; + } + return false; + } + + function isValidAppletAttr(attr) { + return arHas(applet_valid_attrs, attr.toLowerCase()); + } + + function isValidObjectAttr(attr) { + return arHas(object_valid_attrs, attr.toLowerCase()); + } + + /** + * returns true if we can enable DT plugin auto-install without chance of + * deadlock on cert mismatch dialog + * + * requestedJREVersion param is optional - if null, it will be + * treated as installing any JRE version + * + * DT plugin for 6uX only knows about JRE installer signed by SUN cert. + * If it encounter Oracle signed JRE installer, it will have chance of + * deadlock when running with IE. This function is to guard against this. + */ + function enableWithoutCertMisMatchWorkaround(requestedJREVersion) { + + // Non-IE browser are okay + if ('MSIE' != deployJava.browserName) return true; + + // if DT plugin is 10.0.0 or above, return true + // This is because they are aware of both SUN and Oracle signature and + // will not show cert mismatch dialog that might cause deadlock + if (deployJava.compareVersionToPattern(deployJava.getPlugin().version, + ["10", "0", "0"], false, true)) { + return true; + } + + // If we got there, DT plugin is 6uX + + if (requestedJREVersion == null) { + // if requestedJREVersion is not defined - it means ANY. + // can not guarantee it is safe to install ANY version because 6uX + // DT does not know about Oracle certificates and may deadlock + return false; + } + + // 6u32 or earlier JRE installer used Sun certificate + // 6u33+ uses Oracle's certificate + // DT in JRE6 does not know about Oracle certificate => can only + // install 6u32 or earlier without risk of deadlock + return !versionCheckEx("1.6.0_33+", requestedJREVersion); + } + + /* HTML attribute filters */ + + var rv = { + + debug: null, + + /* version of deployJava.js */ + version: "20120801", + + firefoxJavaVersion: null, + + myInterval: null, + preInstallJREList: null, + returnPage: null, + brand: null, + locale: null, + installType: null, + + EAInstallEnabled: false, + EarlyAccessURL: null, + + + // mime-type of the DeployToolkit plugin object + oldMimeType: 'application/npruntime-scriptable-plugin;DeploymentToolkit', + mimeType: 'application/java-deployment-toolkit', + + /* location of the Java Web Start launch button graphic is right next to + * deployJava.js at: + * http://java.com/js/webstart.png + * + * Use protocol less url here for http/https support + */ + launchButtonPNG: getWebStartLaunchIconURL(), + + browserName: null, + browserName2: null, + + /** + * Returns an array of currently-installed JRE version strings. + * Version strings are of the form #.#[.#[_#]], with the function returning + * as much version information as it can determine, from just family + * versions ("1.4.2", "1.5") through the full version ("1.5.0_06"). + * + * Detection is done on a best-effort basis. Under some circumstances + * only the highest installed JRE version will be detected, and + * JREs older than 1.4.2 will not always be detected. + */ + getJREs: function() { + var list = new Array(); + if (this.isPluginInstalled()) { + var plugin = this.getPlugin(); + var VMs = plugin.jvms; + for (var i = 0; i < VMs.getLength(); i++) { + list[i] = VMs.get(i).version; + } + } else { + var browser = this.getBrowser(); + + if (browser == 'MSIE') { + if (this.testUsingActiveX('1.7.0')) { + list[0] = '1.7.0'; + } else if (this.testUsingActiveX('1.6.0')) { + list[0] = '1.6.0'; + } else if (this.testUsingActiveX('1.5.0')) { + list[0] = '1.5.0'; + } else if (this.testUsingActiveX('1.4.2')) { + list[0] = '1.4.2'; + } else if (this.testForMSVM()) { + list[0] = '1.1'; + } + } else if (browser == 'Netscape Family') { + this.getJPIVersionUsingMimeType(); + if (this.firefoxJavaVersion != null) { + list[0] = this.firefoxJavaVersion; + } else if (this.testUsingMimeTypes('1.7')) { + list[0] = '1.7.0'; + } else if (this.testUsingMimeTypes('1.6')) { + list[0] = '1.6.0'; + } else if (this.testUsingMimeTypes('1.5')) { + list[0] = '1.5.0'; + } else if (this.testUsingMimeTypes('1.4.2')) { + list[0] = '1.4.2'; + } else if (this.browserName2 == 'Safari') { + if (this.testUsingPluginsArray('1.7.0')) { + list[0] = '1.7.0'; + } else if (this.testUsingPluginsArray('1.6')) { + list[0] = '1.6.0'; + } else if (this.testUsingPluginsArray('1.5')) { + list[0] = '1.5.0'; + } else if (this.testUsingPluginsArray('1.4.2')) { + list[0] = '1.4.2'; + } + } + } + } + + if (this.debug) { + for (var i = 0; i < list.length; ++i) { + log('[getJREs()] We claim to have detected Java SE ' + list[i]); + } + } + + return list; + }, + + /** + * Triggers a JRE installation. The exact effect of triggering an + * installation varies based on platform, browser, and if the + * Deployment Toolkit plugin is installed. + * + * The requestVersion string is of the form #[.#[.#[_#]]][+|*], + * which includes strings such as "1.4", "1.5.0*", and "1.6.0_02+". + * A star (*) means "any version starting within this family" and + * a plus (+) means "any version greater or equal to this". + * "1.5.0*" * matches 1.5.0_06 but not 1.6.0_01, whereas + * "1.5.0+" matches both. + * + * installCallback is an optional argument which holds a reference + * to a javascript callback function for reporting install status. + * + * If the Deployment Toolkit plugin is not present, this will just call + * this.installLatestJRE(). + */ + installJRE: function(requestVersion, installCallback) { + var ret = false; + if (this.isPluginInstalled() && + this.isAutoInstallEnabled(requestVersion)) { + var installSucceeded = false; + if (this.isCallbackSupported()) { + installSucceeded = + this.getPlugin().installJRE(requestVersion, installCallback); + } else { + installSucceeded = this.getPlugin().installJRE(requestVersion); + } + + if (installSucceeded) { + this.refresh(); + if (this.returnPage != null) { + document.location = this.returnPage; + } + } + return installSucceeded; + } else { + return this.installLatestJRE(); + } + }, + + /** + * returns true if jre auto install for the requestedJREVersion is enabled + * for the local system; false otherwise + * + * requestedJREVersion param is optional - if not specified, it will be + * treated as installing any JRE version + * + * DT plugin for 6uX only knows about JRE installer signed by SUN cert. + * If it encounter Oracle signed JRE installer, it will have chance of + * deadlock when running with IE. This function is to guard against this. + */ + isAutoInstallEnabled: function(requestedJREVersion) { + // if no DT plugin, return false + if (!this.isPluginInstalled()) return false; + + if (typeof requestedJREVersion == 'undefined') { + requestedJREVersion = null; + } + + return enableWithoutCertMisMatchWorkaround(requestedJREVersion); + + }, + + /** + * returns true if jre install callback is supported + * callback support is added since dt plugin version 10.2.0 or above + */ + isCallbackSupported: function() { + return this.isPluginInstalled() && + this.compareVersionToPattern(this.getPlugin().version, + ["10", "2", "0"], false, true); + }, + + /** + * Triggers a JRE installation. The exact effect of triggering an + * installation varies based on platform, browser, and if the + * Deployment Toolkit plugin is installed. + * + * In the simplest case, the browser window will be redirected to the + * java.com JRE installation page, and (if possible) a redirect back to + * the current URL upon successful installation. The return redirect is + * not always possible, as the JRE installation may require the browser to + * be restarted. + * + * installCallback is an optional argument which holds a reference + * to a javascript callback function for reporting install status. + * + * In the best case (when the Deployment Toolkit plugin is present), this + * function will immediately cause a progress dialog to be displayed + * as the JRE is downloaded and installed. + */ + installLatestJRE: function(installCallback) { + if (this.isPluginInstalled() && this.isAutoInstallEnabled()) { + var installSucceeded = false; + if (this.isCallbackSupported()) { + installSucceeded = this.getPlugin().installLatestJRE(installCallback); + } else { + installSucceeded = this.getPlugin().installLatestJRE(); + } + if (installSucceeded) { + this.refresh(); + if (this.returnPage != null) { + document.location = this.returnPage; + } + } + return installSucceeded; + } else { + var browser = this.getBrowser(); + var platform = navigator.platform.toLowerCase(); + if ((this.EAInstallEnabled == 'true') && + (platform.indexOf('win') != -1) && + (this.EarlyAccessURL != null)) { + + this.preInstallJREList = this.getJREs(); + if (this.returnPage != null) { + this.myInterval = + setInterval("deployJava.poll()", 3000); + } + + location.href = this.EarlyAccessURL; + + // we have to return false although there may be an install + // in progress now, when complete it may go to return page + return false; + } else { + if (browser == 'MSIE') { + return this.IEInstall(); + } else if ((browser == 'Netscape Family') && + (platform.indexOf('win32') != -1)) { + return this.FFInstall(); + } else { + location.href = constructGetJavaURL( + ((this.returnPage != null) ? + ('&returnPage=' + this.returnPage) : '') + + ((this.locale != null) ? + ('&locale=' + this.locale) : '') + + ((this.brand != null) ? + ('&brand=' + this.brand) : '')); + } + // we have to return false although there may be an install + // in progress now, when complete it may go to return page + return false; + } + } + }, + + + /** + * Ensures that an appropriate JRE is installed and then runs an applet. + * minimumVersion is of the form #[.#[.#[_#]]], and is the minimum + * JRE version necessary to run this applet. minimumVersion is optional, + * defaulting to the value "1.1" (which matches any JRE). + * If an equal or greater JRE is detected, runApplet() will call + * writeAppletTag(attributes, parameters) to output the applet tag, + * otherwise it will call installJRE(minimumVersion + '+'). + * + * After installJRE() is called, the script will attempt to detect that the + * JRE installation has completed and begin running the applet, but there + * are circumstances (such as when the JRE installation requires a browser + * restart) when this cannot be fulfilled. + * + * As with writeAppletTag(), this function should only be called prior to + * the web page being completely rendered. Note that version wildcards + * (star (*) and plus (+)) are not supported, and including them in the + * minimumVersion will result in an error message. + */ + runApplet: function(attributes, parameters, minimumVersion) { + if (minimumVersion == 'undefined' || minimumVersion == null) { + minimumVersion = '1.1'; + } + + var regex = "^(\\d+)(?:\\.(\\d+)(?:\\.(\\d+)(?:_(\\d+))?)?)?$"; + + var matchData = minimumVersion.match(regex); + + if (this.returnPage == null) { + // if there is an install, come back here and run the applet + this.returnPage = document.location; + } + + if (matchData != null) { + var browser = this.getBrowser(); + if (browser != '?') { + if (this.versionCheck(minimumVersion + '+')) { + this.writeAppletTag(attributes, parameters); + } else if (this.installJRE(minimumVersion + '+')) { + // after successful install we need to refresh page to pick + // pick up new plugin + this.refresh(); + location.href = document.location; + this.writeAppletTag(attributes, parameters); + } + } else { + // for unknown or Safari - just try to show applet + this.writeAppletTag(attributes, parameters); + } + } else { + log('[runApplet()] Invalid minimumVersion argument to runApplet():' + + minimumVersion); + } + }, + + + /** + * Outputs an applet tag with the specified attributes and parameters, where + * both attributes and parameters are associative arrays. Each key/value + * pair in attributes becomes an attribute of the applet tag itself, while + * key/value pairs in parameters become tags. No version checking + * or other special behaviors are performed; the tag is simply written to + * the page using document.writeln(). + * + * As document.writeln() is generally only safe to use while the page is + * being rendered, you should never call this function after the page + * has been completed. + */ + writeAppletTag: function(attributes, parameters) { + var startApplet = '<' + 'applet '; + var params = ''; + var endApplet = '<' + '/' + 'applet' + '>'; + var addCodeAttribute = true; + + if (null == parameters || typeof parameters != 'object') { + parameters = new Object(); + } + + for (var attribute in attributes) { + if (! isValidAppletAttr(attribute)) { + parameters[attribute] = attributes[attribute]; + } else { + startApplet += (' ' +attribute+ '="' +attributes[attribute] + '"'); + if (attribute == 'code') { + addCodeAttribute = false; + } + } + } + + var codebaseParam = false; + for (var parameter in parameters) { + if (parameter == 'codebase_lookup') { + codebaseParam = true; + } + // Originally, parameter 'object' was used for serialized + // applets, later, to avoid confusion with object tag in IE + // the 'java_object' was added. Plugin supports both. + if (parameter == 'object' || parameter == 'java_object' || + parameter == 'java_code' ) { + addCodeAttribute = false; + } + params += ''; + } + if (!codebaseParam) { + params += ''; + } + + if (addCodeAttribute) { + startApplet += (' code="dummy"'); + } + startApplet += '>'; + + document.write(startApplet + '\n' + params + '\n' + endApplet); + }, + + + /** + * Returns true if there is a matching JRE version currently installed + * (among those detected by getJREs()). The versionPattern string is + * of the form #[.#[.#[_#]]][+|*], which includes strings such as "1.4", + * "1.5.0*", and "1.6.0_02+". + * A star (*) means "any version within this family" and a plus (+) means + * "any version greater or equal to the specified version". "1.5.0*" + * matches 1.5.0_06 but not 1.6.0_01, whereas "1.5.0+" matches both. + * + * If the versionPattern does not include all four version components + * but does not end with a star or plus, it will be treated as if it + * ended with a star. "1.5" is exactly equivalent to "1.5*", and will + * match any version number beginning with "1.5". + * + * If getJREs() is unable to detect the precise version number, a match + * could be ambiguous. For example if getJREs() detects "1.5", there is + * no way to know whether the JRE matches "1.5.0_06+". versionCheck() + * compares only as much of the version information as could be detected, + * so versionCheck("1.5.0_06+") would return true in in this case. + * + * Invalid versionPattern will result in a JavaScript error alert. + * versionPatterns which are valid but do not match any existing JRE + * release (e.g. "32.65+") will always return false. + */ + versionCheck: function(versionPattern) + { + var index = 0; + var regex = "^(\\d+)(?:\\.(\\d+)(?:\\.(\\d+)(?:_(\\d+))?)?)?(\\*|\\+)?$"; + + var matchData = versionPattern.match(regex); + + if (matchData != null) { + // default is exact version match + // examples: + // local machine has 1.7.0_04 only installed + // exact match request is "1.7.0_05": return false + // family match request is "1.7.0*": return true + // minimum match request is "1.6+": return true + var familyMatch = false; + var minMatch = false; + + var patternArray = new Array(); + + for (var i = 1; i < matchData.length; ++i) { + // browser dependency here. + // Fx sets 'undefined', IE sets '' string for unmatched groups + if ((typeof matchData[i] == 'string') && (matchData[i] != '')) { + patternArray[index] = matchData[i]; + index++; + } + } + + if (patternArray[patternArray.length-1] == '+') { + // + specified in request - doing a minimum match + minMatch = true; + familyMatch = false; + patternArray.length--; + } else if (patternArray[patternArray.length-1] == '*') { + // * specified in request - doing a family match + minMatch = false; + familyMatch = true; + patternArray.length--; + } else if (patternArray.length < 4) { + // versionPattern does not include all four version components + // and does not end with a star or plus, it will be treated as + // if it ended with a star. (family match) + minMatch = false; + familyMatch = true; + } + + var list = this.getJREs(); + for (var i = 0; i < list.length; ++i) { + if (this.compareVersionToPattern(list[i], patternArray, + familyMatch, minMatch)) { + return true; + } + } + + return false; + } else { + var msg = 'Invalid versionPattern passed to versionCheck: ' + + versionPattern; + log('[versionCheck()] ' + msg); + alert(msg); + return false; + } + }, + + + /** + * Returns true if an installation of Java Web Start of the specified + * minimumVersion can be detected. minimumVersion is optional, and + * if not specified, '1.4.2' will be used. + * (Versions earlier than 1.4.2 may not be detected.) + */ + isWebStartInstalled: function(minimumVersion) { + + var browser = this.getBrowser(); + if (browser == '?') { + // we really don't know - better to try to use it than reinstall + return true; + } + + if (minimumVersion == 'undefined' || minimumVersion == null) { + minimumVersion = '1.4.2'; + } + + var retval = false; + var regex = "^(\\d+)(?:\\.(\\d+)(?:\\.(\\d+)(?:_(\\d+))?)?)?$"; + var matchData = minimumVersion.match(regex); + + if (matchData != null) { + retval = this.versionCheck(minimumVersion + '+'); + } else { + log('[isWebStartInstaller()] Invalid minimumVersion argument to isWebStartInstalled(): ' + minimumVersion); + retval = this.versionCheck('1.4.2+'); + } + return retval; + }, + + // obtain JPI version using navigator.mimeTypes array + // if found, set the version to this.firefoxJavaVersion + getJPIVersionUsingMimeType: function() { + // Walk through the full list of mime types. + for (var i = 0; i < navigator.mimeTypes.length; ++i) { + var s = navigator.mimeTypes[i].type; + // The jpi-version is the plug-in version. This is the best + // version to use. + var m = s.match(/^application\/x-java-applet;jpi-version=(.*)$/); + if (m != null) { + this.firefoxJavaVersion = m[1]; + // Opera puts the latest sun JRE last not first + if ('Opera' != this.browserName2) { + break; + } + } + } + }, + + // launch the specified JNLP application using the passed in jnlp file + // the jnlp file does not need to have a codebase + // this requires JRE 7 or above to work + // if machine has no JRE 7 or above, we will try to auto-install and then launch + // (function will return false if JRE auto-install failed) + launchWebStartApplication: function(jnlp) { + var uaString = navigator.userAgent.toLowerCase(); + + this.getJPIVersionUsingMimeType(); + + // make sure we are JRE 7 or above + if (this.isWebStartInstalled('1.7.0') == false) { + + // perform latest JRE auto-install + if ((this.installJRE('1.7.0+') == false) || + ((this.isWebStartInstalled('1.7.0') == false))) { + return false; + } + } + + var jnlpDocbase = null; + + // use document.documentURI for docbase + if (document.documentURI) { + jnlpDocbase = document.documentURI; + } + + // fallback to document.URL if documentURI not available + if (jnlpDocbase == null) { + jnlpDocbase = document.URL; + } + + var browser = this.getBrowser(); + + var launchTag; + + if (browser == 'MSIE') { + + launchTag = '<' + + 'object classid="clsid:8AD9C840-044E-11D1-B3E9-00805F499D93" ' + + 'width="0" height="0">' + + '<' + 'PARAM name="launchjnlp" value="' + jnlp + '"' + '>' + + '<' + 'PARAM name="docbase" value="' + jnlpDocbase + '"' + '>' + + '<' + '/' + 'object' + '>'; + } else if (browser == 'Netscape Family') { + + launchTag = '<' + + 'embed type="application/x-java-applet;jpi-version=' + + this.firefoxJavaVersion + '" ' + + 'width="0" height="0" ' + + 'launchjnlp="' + jnlp + '"' + + 'docbase="' + jnlpDocbase + '"' + + ' />'; + } + + if (document.body == 'undefined' || document.body == null) { + document.write(launchTag); + // go back to original page, otherwise current page becomes blank + document.location = jnlpDocbase; + } else { + var divTag = document.createElement("div"); + divTag.id = "div1"; + divTag.style.position = "relative"; + divTag.style.left = "-10000px"; + divTag.style.margin = "0px auto"; + divTag.className ="dynamicDiv"; + divTag.innerHTML = launchTag; + document.body.appendChild(divTag); + } + }, + + createWebStartLaunchButtonEx: function(jnlp, minimumVersion) { + + if (this.returnPage == null) { + // if there is an install, come back and run the jnlp file + this.returnPage = jnlp; + } + + var url = 'javascript:deployJava.launchWebStartApplication(\'' + jnlp + + '\');'; + + document.write('<' + 'a href="' + url + + '" onMouseOver="window.status=\'\'; ' + + 'return true;"><' + 'img ' + + 'src="' + this.launchButtonPNG + '" ' + + 'border="0" /><' + '/' + 'a' + '>'); + }, + + + /** + * Outputs a launch button for the specified JNLP URL. When clicked, the + * button will ensure that an appropriate JRE is installed and then launch + * the JNLP application. minimumVersion is of the form #[.#[.#[_#]]], and + * is the minimum JRE version necessary to run this JNLP application. + * minimumVersion is optional, and if it is not specified, '1.4.2' + * will be used. + * If an appropriate JRE or Web Start installation is detected, + * the JNLP application will be launched, otherwise installLatestJRE() + * will be called. + * + * After installLatestJRE() is called, the script will attempt to detect + * that the JRE installation has completed and launch the JNLP application, + * but there are circumstances (such as when the JRE installation + * requires a browser restart) when this cannot be fulfilled. + */ + createWebStartLaunchButton: function(jnlp, minimumVersion) { + + if (this.returnPage == null) { + // if there is an install, come back and run the jnlp file + this.returnPage = jnlp; + } + + var url = 'javascript:' + + 'if (!deployJava.isWebStartInstalled("' + + minimumVersion + '")) {' + + 'if (deployJava.installLatestJRE()) {' + + 'if (deployJava.launch("' + jnlp + '")) {}' + + '}' + + '} else {' + + 'if (deployJava.launch("' + jnlp + '")) {}' + + '}'; + + document.write('<' + 'a href="' + url + + '" onMouseOver="window.status=\'\'; ' + + 'return true;"><' + 'img ' + + 'src="' + this.launchButtonPNG + '" ' + + 'border="0" /><' + '/' + 'a' + '>'); + }, + + + /** + * Launch a JNLP application, (using the plugin if available) + */ + launch: function(jnlp) { + /* + * Using the plugin to launch Java Web Start is disabled for the time being + */ + document.location=jnlp; + return true; + }, + + + /* + * returns true if the ActiveX or XPI plugin is installed + */ + isPluginInstalled: function() { + var plugin = this.getPlugin(); + if (plugin && plugin.jvms) { + return true; + } else { + return false; + } + }, + + /* + * returns true if the plugin is installed and AutoUpdate is enabled + */ + isAutoUpdateEnabled: function() { + if (this.isPluginInstalled()) { + return this.getPlugin().isAutoUpdateEnabled(); + } + return false; + }, + + /* + * sets AutoUpdate on if plugin is installed + */ + setAutoUpdateEnabled: function() { + if (this.isPluginInstalled()) { + return this.getPlugin().setAutoUpdateEnabled(); + } + return false; + }, + + /* + * sets the preferred install type : null, online, kernel + */ + setInstallerType: function(type) { + this.installType = type; + if (this.isPluginInstalled()) { + return this.getPlugin().setInstallerType(type); + } + return false; + }, + + /* + * sets additional package list - to be used by kernel installer + */ + setAdditionalPackages: function(packageList) { + if (this.isPluginInstalled()) { + return this.getPlugin().setAdditionalPackages( + packageList); + } + return false; + }, + + /* + * sets preference to install Early Access versions if available + */ + setEarlyAccess: function(enabled) { + this.EAInstallEnabled = enabled; + }, + + /* + * Determines if the next generation plugin (Plugin II) is default + */ + isPlugin2: function() { + if (this.isPluginInstalled()) { + if (this.versionCheck('1.6.0_10+')) { + try { + return this.getPlugin().isPlugin2(); + } catch (err) { + // older plugin w/o isPlugin2() function - + } + } + } + return false; + }, + + //support native DT plugin? + allowPlugin: function() { + this.getBrowser(); + + // Safari and Opera browsers find the plugin but it + // doesn't work, so until we can get it to work - don't use it. + var ret = ('Safari' != this.browserName2 && + 'Opera' != this.browserName2); + + return ret; + }, + + getPlugin: function() { + this.refresh(); + + var ret = null; + if (this.allowPlugin()) { + ret = document.getElementById('deployJavaPlugin'); + } + return ret; + }, + + compareVersionToPattern: function(version, patternArray, + familyMatch, minMatch) { + if (version == undefined || patternArray == undefined) { + return false; + } + var regex = "^(\\d+)(?:\\.(\\d+)(?:\\.(\\d+)(?:_(\\d+))?)?)?$"; + var matchData = version.match(regex); + + if (matchData != null) { + var index = 0; + var result = new Array(); + + for (var i = 1; i < matchData.length; ++i) { + if ((typeof matchData[i] == 'string') && (matchData[i] != '')) + { + result[index] = matchData[i]; + index++; + } + } + + var l = Math.min(result.length, patternArray.length); + + // result contains what is installed in local machine + // patternArray is what is being requested by application + if (minMatch) { + // minimum version match, return true if what we have (installed) + // is greater or equal to what is requested. false otherwise. + for (var i = 0; i < l; ++i) { + if (result[i] < patternArray[i]) { + return false; + } else if (result[i] > patternArray[i]) { + return true; + } + } + return true; + } else { + for (var i = 0; i < l; ++i) { + if (result[i] != patternArray[i]) return false; + } + if (familyMatch) { + // family match - return true as long as what we have + // (installed) matches up to the request pattern + return true; + } else { + // exact match + // result and patternArray needs to have exact same content + return (result.length == patternArray.length); + } + } + } else { + return false; + } + }, + + getBrowser: function() { + + if (this.browserName == null) { + var browser = navigator.userAgent.toLowerCase(); + + log('[getBrowser()] navigator.userAgent.toLowerCase() -> ' + browser); + + + // order is important here. Safari userAgent contains mozilla, + // IE 11 userAgent contains mozilla and netscape, + // and Chrome userAgent contains both mozilla and safari. + if ((browser.indexOf('msie') != -1) && (browser.indexOf('opera') == -1)) { + this.browserName = 'MSIE'; + this.browserName2 = 'MSIE'; + } else if (browser.indexOf('trident') != -1 || browser.indexOf('Trident') != -1) { + this.browserName = 'MSIE'; + this.browserName2 = 'MSIE'; + } else if (browser.indexOf('iphone') != -1) { + // this included both iPhone and iPad + this.browserName = 'Netscape Family'; + this.browserName2 = 'iPhone'; + } else if ((browser.indexOf('firefox') != -1) && (browser.indexOf('opera') == -1)) { + this.browserName = 'Netscape Family'; + this.browserName2 = 'Firefox'; + } else if (browser.indexOf('chrome') != -1) { + this.browserName = 'Netscape Family'; + this.browserName2 = 'Chrome'; + } else if (browser.indexOf('safari') != -1) { + this.browserName = 'Netscape Family'; + this.browserName2 = 'Safari'; + } else if ((browser.indexOf('mozilla') != -1) && (browser.indexOf('opera') == -1)) { + this.browserName = 'Netscape Family'; + this.browserName2 = 'Other'; + } else if (browser.indexOf('opera') != -1) { + this.browserName = 'Netscape Family'; + this.browserName2 = 'Opera'; + } else { + this.browserName = '?'; + this.browserName2 = 'unknown'; + } + + log('[getBrowser()] Detected browser name:'+ this.browserName + + ', ' + this.browserName2); + } + return this.browserName; + }, + + + testUsingActiveX: function(version) { + var objectName = 'JavaWebStart.isInstalled.' + version + '.0'; + + // we need the typeof check here for this to run on FF/Chrome + // the check needs to be in place here - cannot even pass ActiveXObject + // as arg to another function + if (typeof ActiveXObject == 'undefined' || !ActiveXObject) { + log('[testUsingActiveX()] Browser claims to be IE, but no ActiveXObject object?'); + return false; + } + + try { + return (new ActiveXObject(objectName) != null); + } catch (exception) { + return false; + } + }, + + + testForMSVM: function() { + var clsid = '{08B0E5C0-4FCB-11CF-AAA5-00401C608500}'; + + if (typeof oClientCaps != 'undefined') { + var v = oClientCaps.getComponentVersion(clsid, "ComponentID"); + if ((v == '') || (v == '5,0,5000,0')) { + return false; + } else { + return true; + } + } else { + return false; + } + }, + + + testUsingMimeTypes: function(version) { + if (!navigator.mimeTypes) { + log ('[testUsingMimeTypes()] Browser claims to be Netscape family, but no mimeTypes[] array?'); + return false; + } + + for (var i = 0; i < navigator.mimeTypes.length; ++i) { + s = navigator.mimeTypes[i].type; + var m = s.match(/^application\/x-java-applet\x3Bversion=(1\.8|1\.7|1\.6|1\.5|1\.4\.2)$/); + if (m != null) { + if (this.compareVersions(m[1], version)) { + return true; + } + } + } + return false; + }, + + testUsingPluginsArray: function(version) { + if ((!navigator.plugins) || (!navigator.plugins.length)) { + return false; + } + var platform = navigator.platform.toLowerCase(); + + for (var i = 0; i < navigator.plugins.length; ++i) { + s = navigator.plugins[i].description; + if (s.search(/^Java Switchable Plug-in (Cocoa)/) != -1) { + // Safari on MAC + if (this.compareVersions("1.5.0", version)) { + return true; + } + } else if (s.search(/^Java/) != -1) { + if (platform.indexOf('win') != -1) { + // still can't tell - opera, safari on windows + // return true for 1.5.0 and 1.6.0 + if (this.compareVersions("1.5.0", version) || + this.compareVersions("1.6.0", version)) { + return true; + } + } + } + } + // if above dosn't work on Apple or Windows, just allow 1.5.0 + if (this.compareVersions("1.5.0", version)) { + return true; + } + return false; + + + + }, + + IEInstall: function() { + + location.href = constructGetJavaURL( + ((this.returnPage != null) ? + ('&returnPage=' + this.returnPage) : '') + + ((this.locale != null) ? + ('&locale=' + this.locale) : '') + + ((this.brand != null) ? ('&brand=' + this.brand) : '')); + + // should not actually get here + return false; + }, + + done: function (name, result) { + }, + + FFInstall: function() { + + location.href = constructGetJavaURL( + ((this.returnPage != null) ? + ('&returnPage=' + this.returnPage) : '') + + ((this.locale != null) ? + ('&locale=' + this.locale) : '') + + ((this.brand != null) ? ('&brand=' + this.brand) : '') + + ((this.installType != null) ? + ('&type=' + this.installType) : '')); + + // should not actually get here + return false; + }, + + // return true if 'installed' (considered as a JRE version string) is + // greater than or equal to 'required' (again, a JRE version string). + compareVersions: function(installed, required) { + + var a = installed.split('.'); + var b = required.split('.'); + + for (var i = 0; i < a.length; ++i) { + a[i] = Number(a[i]); + } + for (var i = 0; i < b.length; ++i) { + b[i] = Number(b[i]); + } + if (a.length == 2) { + a[2] = 0; + } + + if (a[0] > b[0]) return true; + if (a[0] < b[0]) return false; + + if (a[1] > b[1]) return true; + if (a[1] < b[1]) return false; + + if (a[2] > b[2]) return true; + if (a[2] < b[2]) return false; + + return true; + }, + + enableAlerts: function() { + // reset this so we can show the browser detection + this.browserName = null; + this.debug = true; + }, + + poll: function() { + + this.refresh(); + var postInstallJREList = this.getJREs(); + + if ((this.preInstallJREList.length == 0) && + (postInstallJREList.length != 0)) { + clearInterval(this.myInterval); + if (this.returnPage != null) { + location.href = this.returnPage; + }; + } + + if ((this.preInstallJREList.length != 0) && + (postInstallJREList.length != 0) && + (this.preInstallJREList[0] != postInstallJREList[0])) { + clearInterval(this.myInterval); + if (this.returnPage != null) { + location.href = this.returnPage; + } + } + + }, + + writePluginTag: function() { + var browser = this.getBrowser(); + + if (browser == 'MSIE') { + document.write('<' + + 'object classid="clsid:CAFEEFAC-DEC7-0000-0001-ABCDEFFEDCBA" ' + + 'id="deployJavaPlugin" width="0" height="0">' + + '<' + '/' + 'object' + '>'); + } else if (browser == 'Netscape Family' && this.allowPlugin()) { + this.writeEmbedTag(); + } + }, + + refresh: function() { + navigator.plugins.refresh(false); + + var browser = this.getBrowser(); + if (browser == 'Netscape Family' && this.allowPlugin()) { + var plugin = document.getElementById('deployJavaPlugin'); + // only do this again if no plugin + if (plugin == null) { + this.writeEmbedTag(); + } + } + }, + + writeEmbedTag: function() { + var written = false; + if (navigator.mimeTypes != null) { + for (var i=0; i < navigator.mimeTypes.length; i++) { + if (navigator.mimeTypes[i].type == this.mimeType) { + if (navigator.mimeTypes[i].enabledPlugin) { + document.write('<' + + 'embed id="deployJavaPlugin" type="' + + this.mimeType + '" hidden="true" />'); + written = true; + } + } + } + // if we ddn't find new mimeType, look for old mimeType + if (!written) for (var i=0; i < navigator.mimeTypes.length; i++) { + if (navigator.mimeTypes[i].type == this.oldMimeType) { + if (navigator.mimeTypes[i].enabledPlugin) { + document.write('<' + + 'embed id="deployJavaPlugin" type="' + + this.oldMimeType + '" hidden="true" />'); + } + } + } + } + } + }; // deployJava object + + rv.writePluginTag(); + if (rv.locale == null) { + var loc = null; + + if (loc == null) try { + loc = navigator.userLanguage; + } catch (err) { } + + if (loc == null) try { + loc = navigator.systemLanguage; + } catch (err) { } + + if (loc == null) try { + loc = navigator.language; + } catch (err) { } + + if (loc != null) { + loc.replace("-","_"); + rv.locale = loc; + } + } + + return rv; +}(); -- cgit v1.2.3