Last active
August 28, 2019 18:58
-
-
Save saschanaz/8bbe4f5270c9cf15acec7ba8b517094a to your computer and use it in GitHub Desktop.
swfobject patch
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // ==UserScript== | |
| // @name swfobject-patch | |
| // @namespace http://saschanaz.github.io/ | |
| // @version 0.2 | |
| // @description try to take over the world! | |
| // @author You | |
| // @match http://*/* | |
| // @grant none | |
| // @run-at document-start | |
| // ==/UserScript== | |
| (() => { | |
| 'use strict'; | |
| if (self.swfobject) { | |
| swfobject.ua.pv = [100, 0, 0]; | |
| return; | |
| } | |
| /* | |
| * SWFObject v2.3.20130521 <http://github.com/swfobject/swfobject> | |
| * is released under the MIT License <http://www.opensource.org/licenses/mit-license.php> | |
| */ | |
| // navigator.plugins["Shockwave Flash"] = { description: "swfobject-patch 100.0 r0" }; | |
| // navigator.mimeTypes["application/x-shockwave-flash"] = { enabledPlugin: true }; | |
| Object.defineProperty(self, "swfobject", { | |
| writable: false, | |
| value: function () { | |
| var UNDEF = "undefined", | |
| OBJECT = "object", | |
| SHOCKWAVE_FLASH = "Shockwave Flash", | |
| SHOCKWAVE_FLASH_AX = "ShockwaveFlash.ShockwaveFlash", | |
| FLASH_MIME_TYPE = "application/x-shockwave-flash", | |
| EXPRESS_INSTALL_ID = "SWFObjectExprInst", | |
| ON_READY_STATE_CHANGE = "onreadystatechange", | |
| win = window, | |
| doc = document, | |
| nav = navigator, | |
| plugin = false, | |
| domLoadFnArr = [], | |
| regObjArr = [], | |
| objIdArr = [], | |
| listenersArr = [], | |
| storedFbContent, | |
| storedFbContentId, | |
| storedCallbackFn, | |
| storedCallbackObj, | |
| isDomLoaded = false, | |
| isExpressInstallActive = false, | |
| dynamicStylesheet, | |
| dynamicStylesheetMedia, | |
| autoHideShow = true, | |
| encodeURIEnabled = false, | |
| /* Centralized function for browser feature detection | |
| - User agent string detection is only used when no good alternative is possible | |
| - Is executed directly for optimal performance | |
| */ | |
| ua = function () { | |
| var w3cdom = typeof doc.getElementById !== UNDEF && typeof doc.getElementsByTagName !== UNDEF && typeof doc.createElement !== UNDEF, | |
| u = nav.userAgent.toLowerCase(), | |
| p = nav.platform.toLowerCase(), | |
| windows = p ? /win/.test(p) : /win/.test(u), | |
| mac = p ? /mac/.test(p) : /mac/.test(u), | |
| webkit = /webkit/.test(u) ? parseFloat(u.replace(/^.*webkit\/(\d+(\.\d+)?).*$/, "$1")) : false, // returns either the webkit version or false if not webkit | |
| ie = nav.appName === "Microsoft Internet Explorer" | |
| return {w3: w3cdom, pv: [100, 0, 0], wk: webkit, ie: ie, win: windows, mac: mac}; | |
| }(), | |
| /* Cross-browser onDomLoad | |
| - Will fire an event as soon as the DOM of a web page is loaded | |
| - Internet Explorer workaround based on Diego Perini's solution: http://javascript.nwbox.com/IEContentLoaded/ | |
| - Regular onload serves as fallback | |
| */ | |
| onDomLoad = function () { | |
| if (!ua.w3) { return; } | |
| if ((typeof doc.readyState !== UNDEF && (doc.readyState === "complete" || doc.readyState === "interactive")) || (typeof doc.readyState === UNDEF && (doc.getElementsByTagName("body")[0] || doc.body))) { // function is fired after onload, e.g. when script is inserted dynamically | |
| callDomLoadFunctions(); | |
| } | |
| if (!isDomLoaded) { | |
| if (typeof doc.addEventListener !== UNDEF) { | |
| doc.addEventListener("DOMContentLoaded", callDomLoadFunctions, false); | |
| } | |
| if (ua.ie) { | |
| doc.attachEvent(ON_READY_STATE_CHANGE, function detach() { | |
| if (doc.readyState === "complete") { | |
| doc.detachEvent(ON_READY_STATE_CHANGE, detach); | |
| callDomLoadFunctions(); | |
| } | |
| }); | |
| if (win == top) { // if not inside an iframe | |
| (function checkDomLoadedIE() { | |
| if (isDomLoaded) { return; } | |
| try { | |
| doc.documentElement.doScroll("left"); | |
| } | |
| catch (e) { | |
| setTimeout(checkDomLoadedIE, 0); | |
| return; | |
| } | |
| callDomLoadFunctions(); | |
| }()); | |
| } | |
| } | |
| if (ua.wk) { | |
| (function checkDomLoadedWK() { | |
| if (isDomLoaded) { return; } | |
| if (!/loaded|complete/.test(doc.readyState)) { | |
| setTimeout(checkDomLoadedWK, 0); | |
| return; | |
| } | |
| callDomLoadFunctions(); | |
| }()); | |
| } | |
| } | |
| }(); | |
| function callDomLoadFunctions() { | |
| if (isDomLoaded || !document.getElementsByTagName("body")[0]) { return; } | |
| try { // test if we can really add/remove elements to/from the DOM; we don't want to fire it too early | |
| var t, span = createElement("span"); | |
| span.style.display = "none"; //hide the span in case someone has styled spans via CSS | |
| t = doc.getElementsByTagName("body")[0].appendChild(span); | |
| t.parentNode.removeChild(t); | |
| t = null; //clear the variables | |
| span = null; | |
| } | |
| catch (e) { return; } | |
| isDomLoaded = true; | |
| var dl = domLoadFnArr.length; | |
| for (var i = 0; i < dl; i++) { | |
| domLoadFnArr[i](); | |
| } | |
| } | |
| function addDomLoadEvent(fn) { | |
| if (isDomLoaded) { | |
| fn(); | |
| } | |
| else { | |
| domLoadFnArr[domLoadFnArr.length] = fn; // Array.push() is only available in IE5.5+ | |
| } | |
| } | |
| /* Cross-browser onload | |
| - Based on James Edwards' solution: http://brothercake.com/site/resources/scripts/onload/ | |
| - Will fire an event as soon as a web page including all of its assets are loaded | |
| */ | |
| function addLoadEvent(fn) { | |
| if (typeof win.addEventListener !== UNDEF) { | |
| win.addEventListener("load", fn, false); | |
| } | |
| else if (typeof doc.addEventListener !== UNDEF) { | |
| doc.addEventListener("load", fn, false); | |
| } | |
| else if (typeof win.attachEvent !== UNDEF) { | |
| addListener(win, "onload", fn); | |
| } | |
| else if (typeof win.onload === "function") { | |
| var fnOld = win.onload; | |
| win.onload = function () { | |
| fnOld(); | |
| fn(); | |
| }; | |
| } | |
| else { | |
| win.onload = fn; | |
| } | |
| } | |
| /* Detect the Flash Player version for non-Internet Explorer browsers | |
| - Detecting the plug-in version via the object element is more precise than using the plugins collection item's description: | |
| a. Both release and build numbers can be detected | |
| b. Avoid wrong descriptions by corrupt installers provided by Adobe | |
| c. Avoid wrong descriptions by multiple Flash Player entries in the plugin Array, caused by incorrect browser imports | |
| - Disadvantage of this method is that it depends on the availability of the DOM, while the plugins collection is immediately available | |
| */ | |
| function testPlayerVersion() { | |
| var b = doc.getElementsByTagName("body")[0]; | |
| var o = createElement(OBJECT); | |
| o.setAttribute("style", "visibility: hidden;"); | |
| o.setAttribute("type", FLASH_MIME_TYPE); | |
| var t = b.appendChild(o); | |
| if (t) { | |
| var counter = 0; | |
| (function checkGetVariable() { | |
| if (typeof t.GetVariable !== UNDEF) { | |
| try { | |
| var d = t.GetVariable("$version"); | |
| if (d) { | |
| d = d.split(" ")[1].split(","); | |
| ua.pv = [toInt(d[0]), toInt(d[1]), toInt(d[2])]; | |
| } | |
| } catch (e) { | |
| //t.GetVariable("$version") is known to fail in Flash Player 8 on Firefox | |
| //If this error is encountered, assume FP8 or lower. Time to upgrade. | |
| ua.pv = [8, 0, 0]; | |
| } | |
| } | |
| else if (counter < 10) { | |
| counter++; | |
| setTimeout(checkGetVariable, 10); | |
| return; | |
| } | |
| b.removeChild(o); | |
| t = null; | |
| matchVersions(); | |
| }()); | |
| } | |
| else { | |
| matchVersions(); | |
| } | |
| } | |
| /* Perform Flash Player and SWF version matching; static publishing only | |
| */ | |
| function matchVersions() { | |
| var rl = regObjArr.length; | |
| if (rl > 0) { | |
| for (var i = 0; i < rl; i++) { // for each registered object element | |
| var id = regObjArr[i].id; | |
| var cb = regObjArr[i].callbackFn; | |
| var cbObj = {success: false, id: id}; | |
| if (ua.pv[0] > 0) { | |
| var obj = getElementById(id); | |
| if (obj) { | |
| if (hasPlayerVersion(regObjArr[i].swfVersion) && !(ua.wk && ua.wk < 312)) { // Flash Player version >= published SWF version: Houston, we have a match! | |
| setVisibility(id, true); | |
| if (cb) { | |
| cbObj.success = true; | |
| cbObj.ref = getObjectById(id); | |
| cbObj.id = id; | |
| cb(cbObj); | |
| } | |
| } | |
| else if (regObjArr[i].expressInstall && canExpressInstall()) { // show the Adobe Express Install dialog if set by the web page author and if supported | |
| var att = {}; | |
| att.data = regObjArr[i].expressInstall; | |
| att.width = obj.getAttribute("width") || "0"; | |
| att.height = obj.getAttribute("height") || "0"; | |
| if (obj.getAttribute("class")) { att.styleclass = obj.getAttribute("class"); } | |
| if (obj.getAttribute("align")) { att.align = obj.getAttribute("align"); } | |
| // parse HTML object param element's name-value pairs | |
| var par = {}; | |
| var p = obj.getElementsByTagName("param"); | |
| var pl = p.length; | |
| for (var j = 0; j < pl; j++) { | |
| if (p[j].getAttribute("name").toLowerCase() !== "movie") { | |
| par[p[j].getAttribute("name")] = p[j].getAttribute("value"); | |
| } | |
| } | |
| showExpressInstall(att, par, id, cb); | |
| } | |
| else { // Flash Player and SWF version mismatch or an older Webkit engine that ignores the HTML object element's nested param elements: display fallback content instead of SWF | |
| displayFbContent(obj); | |
| if (cb) { cb(cbObj); } | |
| } | |
| } | |
| } | |
| else { // if no Flash Player is installed or the fp version cannot be detected we let the HTML object element do its job (either show a SWF or fallback content) | |
| setVisibility(id, true); | |
| if (cb) { | |
| var o = getObjectById(id); // test whether there is an HTML object element or not | |
| if (o && typeof o.SetVariable !== UNDEF) { | |
| cbObj.success = true; | |
| cbObj.ref = o; | |
| cbObj.id = o.id; | |
| } | |
| cb(cbObj); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /* Main function | |
| - Will preferably execute onDomLoad, otherwise onload (as a fallback) | |
| */ | |
| domLoadFnArr[0] = function () { | |
| if (plugin) { | |
| testPlayerVersion(); | |
| } | |
| else { | |
| matchVersions(); | |
| } | |
| }; | |
| function getObjectById(objectIdStr) { | |
| var r = null, | |
| o = getElementById(objectIdStr); | |
| if (o && o.nodeName.toUpperCase() === "OBJECT") { | |
| //If targeted object is valid Flash file | |
| if (typeof o.SetVariable !== UNDEF) { | |
| r = o; | |
| } else { | |
| //If SetVariable is not working on targeted object but a nested object is | |
| //available, assume classic nested object markup. Return nested object. | |
| //If SetVariable is not working on targeted object and there is no nested object, | |
| //return the original object anyway. This is probably new simplified markup. | |
| r = o.getElementsByTagName(OBJECT)[0] || o; | |
| } | |
| } | |
| return r; | |
| } | |
| /* Requirements for Adobe Express Install | |
| - only one instance can be active at a time | |
| - fp 6.0.65 or higher | |
| - Win/Mac OS only | |
| - no Webkit engines older than version 312 | |
| */ | |
| function canExpressInstall() { | |
| return !isExpressInstallActive && hasPlayerVersion("6.0.65") && (ua.win || ua.mac) && !(ua.wk && ua.wk < 312); | |
| } | |
| /* Show the Adobe Express Install dialog | |
| - Reference: http://www.adobe.com/cfusion/knowledgebase/index.cfm?id=6a253b75 | |
| */ | |
| function showExpressInstall(att, par, replaceElemIdStr, callbackFn) { | |
| var obj = getElementById(replaceElemIdStr); | |
| //Ensure that replaceElemIdStr is really a string and not an element | |
| replaceElemIdStr = getId(replaceElemIdStr); | |
| isExpressInstallActive = true; | |
| storedCallbackFn = callbackFn || null; | |
| storedCallbackObj = {success: false, id: replaceElemIdStr}; | |
| if (obj) { | |
| if (obj.nodeName.toUpperCase() === "OBJECT") { // static publishing | |
| storedFbContent = abstractFbContent(obj); | |
| storedFbContentId = null; | |
| } | |
| else { // dynamic publishing | |
| storedFbContent = obj; | |
| storedFbContentId = replaceElemIdStr; | |
| } | |
| att.id = EXPRESS_INSTALL_ID; | |
| if (typeof att.width === UNDEF || (!/%$/.test(att.width) && toInt(att.width) < 310)) { att.width = "310"; } | |
| if (typeof att.height === UNDEF || (!/%$/.test(att.height) && toInt(att.height) < 137)) { att.height = "137"; } | |
| var pt = ua.ie ? "ActiveX" : "PlugIn", | |
| fv = "MMredirectURL=" + encodeURIComponent(win.location.toString().replace(/&/g, "%26")) + "&MMplayerType=" + pt + "&MMdoctitle=" + encodeURIComponent(doc.title.slice(0, 47) + " - Flash Player Installation"); | |
| if (typeof par.flashvars !== UNDEF) { | |
| par.flashvars += "&" + fv; | |
| } | |
| else { | |
| par.flashvars = fv; | |
| } | |
| // IE only: when a SWF is loading (AND: not available in cache) wait for the readyState of the object element to become 4 before removing it, | |
| // because you cannot properly cancel a loading SWF file without breaking browser load references, also obj.onreadystatechange doesn't work | |
| if (ua.ie && obj.readyState != 4) { | |
| var newObj = createElement("div"); | |
| replaceElemIdStr += "SWFObjectNew"; | |
| newObj.setAttribute("id", replaceElemIdStr); | |
| obj.parentNode.insertBefore(newObj, obj); // insert placeholder div that will be replaced by the object element that loads expressinstall.swf | |
| obj.style.display = "none"; | |
| removeSWF(obj); //removeSWF accepts elements now | |
| } | |
| createSWF(att, par, replaceElemIdStr); | |
| } | |
| } | |
| /* Functions to abstract and display fallback content | |
| */ | |
| function displayFbContent(obj) { | |
| if (ua.ie && obj.readyState != 4) { | |
| // IE only: when a SWF is loading (AND: not available in cache) wait for the readyState of the object element to become 4 before removing it, | |
| // because you cannot properly cancel a loading SWF file without breaking browser load references, also obj.onreadystatechange doesn't work | |
| obj.style.display = "none"; | |
| var el = createElement("div"); | |
| obj.parentNode.insertBefore(el, obj); // insert placeholder div that will be replaced by the fallback content | |
| el.parentNode.replaceChild(abstractFbContent(obj), el); | |
| removeSWF(obj); //removeSWF accepts elements now | |
| } | |
| else { | |
| obj.parentNode.replaceChild(abstractFbContent(obj), obj); | |
| } | |
| } | |
| function abstractFbContent(obj) { | |
| var ac = createElement("div"); | |
| if (ua.win && ua.ie) { | |
| ac.innerHTML = obj.innerHTML; | |
| } | |
| else { | |
| var nestedObj = obj.getElementsByTagName(OBJECT)[0]; | |
| if (nestedObj) { | |
| var c = nestedObj.childNodes; | |
| if (c) { | |
| var cl = c.length; | |
| for (var i = 0; i < cl; i++) { | |
| if (!(c[i].nodeType == 1 && c[i].nodeName === "PARAM") && !(c[i].nodeType == 8)) { | |
| ac.appendChild(c[i].cloneNode(true)); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return ac; | |
| } | |
| function createIeObject(url, paramStr) { | |
| var div = createElement("div"); | |
| div.innerHTML = "<object classid='clsid:D27CDB6E-AE6D-11cf-96B8-444553540000'><param name='movie' value='" + url + "'>" + paramStr + "</object>"; | |
| return div.firstChild; | |
| } | |
| /* Cross-browser dynamic SWF creation | |
| */ | |
| function createSWF(attObj, parObj, id) { | |
| var r, el = getElementById(id); | |
| id = getId(id); // ensure id is truly an ID and not an element | |
| if (ua.wk && ua.wk < 312) { return r; } | |
| if (el) { | |
| var o = (ua.ie) ? createElement("div") : createElement(OBJECT), | |
| attr, | |
| attrLower, | |
| param; | |
| if (typeof attObj.id === UNDEF) { // if no 'id' is defined for the object element, it will inherit the 'id' from the fallback content | |
| attObj.id = id; | |
| } | |
| //Add params | |
| for (param in parObj) { | |
| //filter out prototype additions from other potential libraries and IE specific param element | |
| if (parObj.hasOwnProperty(param) && param.toLowerCase() !== "movie") { | |
| createObjParam(o, param, parObj[param]); | |
| } | |
| } | |
| //Create IE object, complete with param nodes | |
| if (ua.ie) { o = createIeObject(attObj.data, o.innerHTML); } | |
| //Add attributes to object | |
| for (attr in attObj) { | |
| if (attObj.hasOwnProperty(attr)) { // filter out prototype additions from other potential libraries | |
| attrLower = attr.toLowerCase(); | |
| // 'class' is an ECMA4 reserved keyword | |
| if (attrLower === "styleclass") { | |
| o.setAttribute("class", attObj[attr]); | |
| } else if (attrLower !== "classid" && attrLower !== "data") { | |
| o.setAttribute(attr, attObj[attr]); | |
| } | |
| } | |
| } | |
| if (ua.ie) { | |
| objIdArr[objIdArr.length] = attObj.id; // stored to fix object 'leaks' on unload (dynamic publishing only) | |
| } else { | |
| o.setAttribute("type", FLASH_MIME_TYPE); | |
| o.setAttribute("data", attObj.data); | |
| } | |
| el.parentNode.replaceChild(o, el); | |
| r = o; | |
| } | |
| return r; | |
| } | |
| function createObjParam(el, pName, pValue) { | |
| var p = createElement("param"); | |
| p.setAttribute("name", pName); | |
| p.setAttribute("value", pValue); | |
| el.appendChild(p); | |
| } | |
| /* Cross-browser SWF removal | |
| - Especially needed to safely and completely remove a SWF in Internet Explorer | |
| */ | |
| function removeSWF(id) { | |
| var obj = getElementById(id); | |
| if (obj && obj.nodeName.toUpperCase() === "OBJECT") { | |
| if (ua.ie) { | |
| obj.style.display = "none"; | |
| (function removeSWFInIE() { | |
| if (obj.readyState == 4) { | |
| //This step prevents memory leaks in Internet Explorer | |
| for (var i in obj) { | |
| if (typeof obj[i] === "function") { | |
| obj[i] = null; | |
| } | |
| } | |
| obj.parentNode.removeChild(obj); | |
| } else { | |
| setTimeout(removeSWFInIE, 10); | |
| } | |
| }()); | |
| } | |
| else { | |
| obj.parentNode.removeChild(obj); | |
| } | |
| } | |
| } | |
| function isElement(id) { | |
| return (id && id.nodeType && id.nodeType === 1); | |
| } | |
| function getId(thing) { | |
| return (isElement(thing)) ? thing.id : thing; | |
| } | |
| /* Functions to optimize JavaScript compression | |
| */ | |
| function getElementById(id) { | |
| //Allow users to pass an element OR an element's ID | |
| if (isElement(id)) { return id; } | |
| var el = null; | |
| try { | |
| el = doc.getElementById(id); | |
| } | |
| catch (e) {} | |
| return el; | |
| } | |
| function createElement(el) { | |
| return doc.createElement(el); | |
| } | |
| //To aid compression; replaces 14 instances of pareseInt with radix | |
| function toInt(str) { | |
| return parseInt(str, 10); | |
| } | |
| /* Updated attachEvent function for Internet Explorer | |
| - Stores attachEvent information in an Array, so on unload the detachEvent functions can be called to avoid memory leaks | |
| */ | |
| function addListener(target, eventType, fn) { | |
| target.attachEvent(eventType, fn); | |
| listenersArr[listenersArr.length] = [target, eventType, fn]; | |
| } | |
| /* Flash Player and SWF content version matching | |
| */ | |
| function hasPlayerVersion(rv) { | |
| rv += ""; //Coerce number to string, if needed. | |
| var pv = ua.pv, v = rv.split("."); | |
| v[0] = toInt(v[0]); | |
| v[1] = toInt(v[1]) || 0; // supports short notation, e.g. "9" instead of "9.0.0" | |
| v[2] = toInt(v[2]) || 0; | |
| return (pv[0] > v[0] || (pv[0] == v[0] && pv[1] > v[1]) || (pv[0] == v[0] && pv[1] == v[1] && pv[2] >= v[2])) ? true : false; | |
| } | |
| /* Cross-browser dynamic CSS creation | |
| - Based on Bobby van der Sluis' solution: http://www.bobbyvandersluis.com/articles/dynamicCSS.php | |
| */ | |
| function createCSS(sel, decl, media, newStyle) { | |
| var h = doc.getElementsByTagName("head")[0]; | |
| if (!h) { return; } // to also support badly authored HTML pages that lack a head element | |
| var m = (typeof media === "string") ? media : "screen"; | |
| if (newStyle) { | |
| dynamicStylesheet = null; | |
| dynamicStylesheetMedia = null; | |
| } | |
| if (!dynamicStylesheet || dynamicStylesheetMedia != m) { | |
| // create dynamic stylesheet + get a global reference to it | |
| var s = createElement("style"); | |
| s.setAttribute("type", "text/css"); | |
| s.setAttribute("media", m); | |
| dynamicStylesheet = h.appendChild(s); | |
| if (ua.ie && typeof doc.styleSheets !== UNDEF && doc.styleSheets.length > 0) { | |
| dynamicStylesheet = doc.styleSheets[doc.styleSheets.length - 1]; | |
| } | |
| dynamicStylesheetMedia = m; | |
| } | |
| // add style rule | |
| if (dynamicStylesheet) { | |
| if (typeof dynamicStylesheet.addRule !== UNDEF) { | |
| dynamicStylesheet.addRule(sel, decl); | |
| } else if (typeof doc.createTextNode !== UNDEF) { | |
| dynamicStylesheet.appendChild(doc.createTextNode(sel + " {" + decl + "}")); | |
| } | |
| } | |
| } | |
| function setVisibility(id, isVisible) { | |
| if (!autoHideShow) { return; } | |
| var v = isVisible ? "visible" : "hidden", | |
| el = getElementById(id); | |
| if (isDomLoaded && el) { | |
| el.style.visibility = v; | |
| } else if (typeof id === "string") { | |
| createCSS("#" + id, "visibility:" + v); | |
| } | |
| } | |
| /* Filter to avoid XSS attacks | |
| */ | |
| function urlEncodeIfNecessary(s) { | |
| var regex = /[\\\"<>\.;]/; | |
| var hasBadChars = regex.exec(s) !== null; | |
| return hasBadChars && typeof encodeURIComponent !== UNDEF ? encodeURIComponent(s) : s; | |
| } | |
| /* Release memory to avoid memory leaks caused by closures, fix hanging audio/video threads and force open sockets/NetConnections to disconnect (Internet Explorer only) | |
| */ | |
| var cleanup = function () { | |
| if (ua.ie) { | |
| window.attachEvent("onunload", function () { | |
| // remove listeners to avoid memory leaks | |
| var ll = listenersArr.length; | |
| for (var i = 0; i < ll; i++) { | |
| listenersArr[i][0].detachEvent(listenersArr[i][1], listenersArr[i][2]); | |
| } | |
| // cleanup dynamically embedded objects to fix audio/video threads and force open sockets and NetConnections to disconnect | |
| var il = objIdArr.length; | |
| for (var j = 0; j < il; j++) { | |
| removeSWF(objIdArr[j]); | |
| } | |
| // cleanup library's main closures to avoid memory leaks | |
| for (var k in ua) { | |
| ua[k] = null; | |
| } | |
| ua = null; | |
| for (var l in swfobject) { | |
| swfobject[l] = null; | |
| } | |
| swfobject = null; | |
| }); | |
| } | |
| }(); | |
| return { | |
| /* Public API | |
| - Reference: http://code.google.com/p/swfobject/wiki/documentation | |
| */ | |
| registerObject: function (objectIdStr, swfVersionStr, xiSwfUrlStr, callbackFn) { | |
| if (ua.w3 && objectIdStr && swfVersionStr) { | |
| var regObj = {}; | |
| regObj.id = objectIdStr; | |
| regObj.swfVersion = swfVersionStr; | |
| regObj.expressInstall = xiSwfUrlStr; | |
| regObj.callbackFn = callbackFn; | |
| regObjArr[regObjArr.length] = regObj; | |
| setVisibility(objectIdStr, false); | |
| } | |
| else if (callbackFn) { | |
| callbackFn({success: false, id: objectIdStr}); | |
| } | |
| }, | |
| getObjectById: function (objectIdStr) { | |
| if (ua.w3) { | |
| return getObjectById(objectIdStr); | |
| } | |
| }, | |
| embedSWF: function (swfUrlStr, replaceElemIdStr, widthStr, heightStr, swfVersionStr, xiSwfUrlStr, flashvarsObj, parObj, attObj, callbackFn) { | |
| var id = getId(replaceElemIdStr), | |
| callbackObj = {success: false, id: id}; | |
| if (ua.w3 && !(ua.wk && ua.wk < 312) && swfUrlStr && replaceElemIdStr && widthStr && heightStr && swfVersionStr) { | |
| setVisibility(id, false); | |
| addDomLoadEvent(function () { | |
| widthStr += ""; // auto-convert to string | |
| heightStr += ""; | |
| var att = {}; | |
| if (attObj && typeof attObj === OBJECT) { | |
| for (var i in attObj) { // copy object to avoid the use of references, because web authors often reuse attObj for multiple SWFs | |
| att[i] = attObj[i]; | |
| } | |
| } | |
| att.data = swfUrlStr; | |
| att.width = widthStr; | |
| att.height = heightStr; | |
| var par = {}; | |
| if (parObj && typeof parObj === OBJECT) { | |
| for (var j in parObj) { // copy object to avoid the use of references, because web authors often reuse parObj for multiple SWFs | |
| par[j] = parObj[j]; | |
| } | |
| } | |
| if (flashvarsObj && typeof flashvarsObj === OBJECT) { | |
| for (var k in flashvarsObj) { // copy object to avoid the use of references, because web authors often reuse flashvarsObj for multiple SWFs | |
| if (flashvarsObj.hasOwnProperty(k)) { | |
| var key = (encodeURIEnabled) ? encodeURIComponent(k) : k, | |
| value = (encodeURIEnabled) ? encodeURIComponent(flashvarsObj[k]) : flashvarsObj[k]; | |
| if (typeof par.flashvars !== UNDEF) { | |
| par.flashvars += "&" + key + "=" + value; | |
| } | |
| else { | |
| par.flashvars = key + "=" + value; | |
| } | |
| } | |
| } | |
| } | |
| if (hasPlayerVersion(swfVersionStr)) { // create SWF | |
| var obj = createSWF(att, par, replaceElemIdStr); | |
| if (att.id == id) { | |
| setVisibility(id, true); | |
| } | |
| callbackObj.success = true; | |
| callbackObj.ref = obj; | |
| callbackObj.id = obj.id; | |
| } | |
| else if (xiSwfUrlStr && canExpressInstall()) { // show Adobe Express Install | |
| att.data = xiSwfUrlStr; | |
| showExpressInstall(att, par, replaceElemIdStr, callbackFn); | |
| return; | |
| } | |
| else { // show fallback content | |
| setVisibility(id, true); | |
| } | |
| if (callbackFn) { callbackFn(callbackObj); } | |
| }); | |
| } | |
| else if (callbackFn) { callbackFn(callbackObj); } | |
| }, | |
| switchOffAutoHideShow: function () { | |
| autoHideShow = false; | |
| }, | |
| enableUriEncoding: function (bool) { | |
| encodeURIEnabled = (typeof bool === UNDEF) ? true : bool; | |
| }, | |
| ua: ua, | |
| getFlashPlayerVersion: function () { | |
| return {major: ua.pv[0], minor: ua.pv[1], release: ua.pv[2]}; | |
| }, | |
| hasFlashPlayerVersion: hasPlayerVersion, | |
| createSWF: function (attObj, parObj, replaceElemIdStr) { | |
| if (ua.w3) { | |
| return createSWF(attObj, parObj, replaceElemIdStr); | |
| } | |
| else { | |
| return undefined; | |
| } | |
| }, | |
| showExpressInstall: function (att, par, replaceElemIdStr, callbackFn) { | |
| if (ua.w3 && canExpressInstall()) { | |
| showExpressInstall(att, par, replaceElemIdStr, callbackFn); | |
| } | |
| }, | |
| removeSWF: function (objElemIdStr) { | |
| if (ua.w3) { | |
| removeSWF(objElemIdStr); | |
| } | |
| }, | |
| createCSS: function (selStr, declStr, mediaStr, newStyleBoolean) { | |
| if (ua.w3) { | |
| createCSS(selStr, declStr, mediaStr, newStyleBoolean); | |
| } | |
| }, | |
| addDomLoadEvent: addDomLoadEvent, | |
| addLoadEvent: addLoadEvent, | |
| getQueryParamValue: function (param) { | |
| var q = doc.location.search || doc.location.hash; | |
| if (q) { | |
| if (/\?/.test(q)) { q = q.split("?")[1]; } // strip question mark | |
| if (!param) { | |
| return urlEncodeIfNecessary(q); | |
| } | |
| var pairs = q.split("&"); | |
| for (var i = 0; i < pairs.length; i++) { | |
| if (pairs[i].substring(0, pairs[i].indexOf("=")) == param) { | |
| return urlEncodeIfNecessary(pairs[i].substring((pairs[i].indexOf("=") + 1))); | |
| } | |
| } | |
| } | |
| return ""; | |
| }, | |
| // For internal usage only | |
| expressInstallCallback: function () { | |
| if (isExpressInstallActive) { | |
| var obj = getElementById(EXPRESS_INSTALL_ID); | |
| if (obj && storedFbContent) { | |
| obj.parentNode.replaceChild(storedFbContent, obj); | |
| if (storedFbContentId) { | |
| setVisibility(storedFbContentId, true); | |
| if (ua.ie) { storedFbContent.style.display = "block"; } | |
| } | |
| if (storedCallbackFn) { storedCallbackFn(storedCallbackObj); } | |
| } | |
| isExpressInstallActive = false; | |
| } | |
| }, | |
| version: "2.3" | |
| }; | |
| }() | |
| }); | |
| })(); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
It's a bit hard to read the diff because of all the formatting changes. I'm wondering if you've run into any situation where the flash object doesn't render in chrome (but is in the DOM with all params, size, etc) and then appears only after chrome zoom is toggled? I'm trying to solve for that issue, but wondering if any of your changes are worth looking into for that purpose.