mirror of https://gitee.com/jeecg/jeecg.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2596 lines
72 KiB
2596 lines
72 KiB
/*
|
|
SWFObject v2.2 <http://code.google.com/p/swfobject/>
|
|
is released under the MIT License <http://www.opensource.org/licenses/mit-license.php>
|
|
*/
|
|
var swfobject = function() {
|
|
var D = "undefined", r = "object", S = "Shockwave Flash", W = "ShockwaveFlash.ShockwaveFlash", q = "application/x-shockwave-flash", R = "SWFObjectExprInst", x = "onreadystatechange", O = window, j = document, t = navigator, T = false, U = [ h ], o = [], N = [], I = [], l, Q, E, B, J = false, a = false, n, G, m = true, M = function() {
|
|
var aa = typeof j.getElementById != D
|
|
&& typeof j.getElementsByTagName != D
|
|
&& typeof j.createElement != D, ah = t.userAgent.toLowerCase(), Y = t.platform
|
|
.toLowerCase(), ae = Y ? /win/.test(Y) : /win/.test(ah), ac = Y ? /mac/
|
|
.test(Y)
|
|
: /mac/.test(ah), af = /webkit/.test(ah) ? parseFloat(ah
|
|
.replace(/^.*webkit\/(\d+(\.\d+)?).*$/, "$1")) : false, X = !+"\v1", ag = [
|
|
0, 0, 0 ], ab = null;
|
|
if (typeof t.plugins != D && typeof t.plugins[S] == r) {
|
|
ab = t.plugins[S].description;
|
|
if (ab
|
|
&& !(typeof t.mimeTypes != D && t.mimeTypes[q] && !t.mimeTypes[q].enabledPlugin)) {
|
|
T = true;
|
|
X = false;
|
|
ab = ab.replace(/^.*\s+(\S+\s+\S+$)/, "$1");
|
|
ag[0] = parseInt(ab.replace(/^(.*)\..*$/, "$1"), 10);
|
|
ag[1] = parseInt(ab.replace(/^.*\.(.*)\s.*$/, "$1"), 10);
|
|
ag[2] = /[a-zA-Z]/.test(ab) ? parseInt(ab.replace(
|
|
/^.*[a-zA-Z]+(.*)$/, "$1"), 10) : 0;
|
|
}
|
|
} else {
|
|
if (typeof O.ActiveXObject != D) {
|
|
try {
|
|
var ad = new ActiveXObject(W);
|
|
if (ad) {
|
|
ab = ad.GetVariable("$version");
|
|
if (ab) {
|
|
X = true;
|
|
ab = ab.split(" ")[1].split(",");
|
|
ag = [ parseInt(ab[0], 10), parseInt(ab[1], 10),
|
|
parseInt(ab[2], 10) ];
|
|
}
|
|
}
|
|
} catch (Z) {
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
w3 : aa,
|
|
pv : ag,
|
|
wk : af,
|
|
ie : X,
|
|
win : ae,
|
|
mac : ac
|
|
};
|
|
}(), k = function() {
|
|
if (!M.w3) {
|
|
return;
|
|
}
|
|
if ((typeof j.readyState != D && j.readyState == "complete")
|
|
|| (typeof j.readyState == D && (j.getElementsByTagName("body")[0] || j.body))) {
|
|
f();
|
|
}
|
|
if (!J) {
|
|
if (typeof j.addEventListener != D) {
|
|
j.addEventListener("DOMContentLoaded", f, false);
|
|
}
|
|
if (M.ie && M.win) {
|
|
j.attachEvent(x, function() {
|
|
if (j.readyState == "complete") {
|
|
j.detachEvent(x, arguments.callee);
|
|
f();
|
|
}
|
|
});
|
|
if (O == top) {
|
|
(function() {
|
|
if (J) {
|
|
return;
|
|
}
|
|
try {
|
|
j.documentElement.doScroll("left");
|
|
} catch (X) {
|
|
setTimeout(arguments.callee, 0);
|
|
return;
|
|
}
|
|
f();
|
|
})();
|
|
}
|
|
}
|
|
if (M.wk) {
|
|
(function() {
|
|
if (J) {
|
|
return;
|
|
}
|
|
if (!/loaded|complete/.test(j.readyState)) {
|
|
setTimeout(arguments.callee, 0);
|
|
return;
|
|
}
|
|
f();
|
|
})();
|
|
}
|
|
s(f);
|
|
}
|
|
}();
|
|
function f() {
|
|
if (J) {
|
|
return;
|
|
}
|
|
try {
|
|
var Z = j.getElementsByTagName("body")[0].appendChild(C("span"));
|
|
Z.parentNode.removeChild(Z);
|
|
} catch (aa) {
|
|
return;
|
|
}
|
|
J = true;
|
|
var X = U.length;
|
|
for ( var Y = 0; Y < X; Y++) {
|
|
U[Y]();
|
|
}
|
|
}
|
|
function K(X) {
|
|
if (J) {
|
|
X();
|
|
} else {
|
|
U[U.length] = X;
|
|
}
|
|
}
|
|
function s(Y) {
|
|
if (typeof O.addEventListener != D) {
|
|
O.addEventListener("load", Y, false);
|
|
} else {
|
|
if (typeof j.addEventListener != D) {
|
|
j.addEventListener("load", Y, false);
|
|
} else {
|
|
if (typeof O.attachEvent != D) {
|
|
i(O, "onload", Y);
|
|
} else {
|
|
if (typeof O.onload == "function") {
|
|
var X = O.onload;
|
|
O.onload = function() {
|
|
X();
|
|
Y();
|
|
};
|
|
} else {
|
|
O.onload = Y;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function h() {
|
|
if (T) {
|
|
V();
|
|
} else {
|
|
H();
|
|
}
|
|
}
|
|
function V() {
|
|
var X = j.getElementsByTagName("body")[0];
|
|
var aa = C(r);
|
|
aa.setAttribute("type", q);
|
|
var Z = X.appendChild(aa);
|
|
if (Z) {
|
|
var Y = 0;
|
|
(function() {
|
|
if (typeof Z.GetVariable != D) {
|
|
var ab = Z.GetVariable("$version");
|
|
if (ab) {
|
|
ab = ab.split(" ")[1].split(",");
|
|
M.pv = [ parseInt(ab[0], 10), parseInt(ab[1], 10),
|
|
parseInt(ab[2], 10) ];
|
|
}
|
|
} else {
|
|
if (Y < 10) {
|
|
Y++;
|
|
setTimeout(arguments.callee, 10);
|
|
return;
|
|
}
|
|
}
|
|
X.removeChild(aa);
|
|
Z = null;
|
|
H();
|
|
})();
|
|
} else {
|
|
H();
|
|
}
|
|
}
|
|
function H() {
|
|
var ag = o.length;
|
|
if (ag > 0) {
|
|
for ( var af = 0; af < ag; af++) {
|
|
var Y = o[af].id;
|
|
var ab = o[af].callbackFn;
|
|
var aa = {
|
|
success : false,
|
|
id : Y
|
|
};
|
|
if (M.pv[0] > 0) {
|
|
var ae = c(Y);
|
|
if (ae) {
|
|
if (F(o[af].swfVersion) && !(M.wk && M.wk < 312)) {
|
|
w(Y, true);
|
|
if (ab) {
|
|
aa.success = true;
|
|
aa.ref = z(Y);
|
|
ab(aa);
|
|
}
|
|
} else {
|
|
if (o[af].expressInstall && A()) {
|
|
var ai = {};
|
|
ai.data = o[af].expressInstall;
|
|
ai.width = ae.getAttribute("width") || "0";
|
|
ai.height = ae.getAttribute("height") || "0";
|
|
if (ae.getAttribute("class")) {
|
|
ai.styleclass = ae.getAttribute("class");
|
|
}
|
|
if (ae.getAttribute("align")) {
|
|
ai.align = ae.getAttribute("align");
|
|
}
|
|
var ah = {};
|
|
var X = ae.getElementsByTagName("param");
|
|
var ac = X.length;
|
|
for ( var ad = 0; ad < ac; ad++) {
|
|
if (X[ad].getAttribute("name")
|
|
.toLowerCase() != "movie") {
|
|
ah[X[ad].getAttribute("name")] = X[ad]
|
|
.getAttribute("value");
|
|
}
|
|
}
|
|
P(ai, ah, Y, ab);
|
|
} else {
|
|
p(ae);
|
|
if (ab) {
|
|
ab(aa);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
w(Y, true);
|
|
if (ab) {
|
|
var Z = z(Y);
|
|
if (Z && typeof Z.SetVariable != D) {
|
|
aa.success = true;
|
|
aa.ref = Z;
|
|
}
|
|
ab(aa);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function z(aa) {
|
|
var X = null;
|
|
var Y = c(aa);
|
|
if (Y && Y.nodeName == "OBJECT") {
|
|
if (typeof Y.SetVariable != D) {
|
|
X = Y;
|
|
} else {
|
|
var Z = Y.getElementsByTagName(r)[0];
|
|
if (Z) {
|
|
X = Z;
|
|
}
|
|
}
|
|
}
|
|
return X;
|
|
}
|
|
function A() {
|
|
return !a && F("6.0.65") && (M.win || M.mac) && !(M.wk && M.wk < 312);
|
|
}
|
|
function P(aa, ab, X, Z) {
|
|
a = true;
|
|
E = Z || null;
|
|
B = {
|
|
success : false,
|
|
id : X
|
|
};
|
|
var ae = c(X);
|
|
if (ae) {
|
|
if (ae.nodeName == "OBJECT") {
|
|
l = g(ae);
|
|
Q = null;
|
|
} else {
|
|
l = ae;
|
|
Q = X;
|
|
}
|
|
aa.id = R;
|
|
if (typeof aa.width == D
|
|
|| (!/%$/.test(aa.width) && parseInt(aa.width, 10) < 310)) {
|
|
aa.width = "310";
|
|
}
|
|
if (typeof aa.height == D
|
|
|| (!/%$/.test(aa.height) && parseInt(aa.height, 10) < 137)) {
|
|
aa.height = "137";
|
|
}
|
|
j.title = j.title.slice(0, 47) + " - Flash Player Installation";
|
|
var ad = M.ie && M.win ? "ActiveX" : "PlugIn", ac = "MMredirectURL="
|
|
+ O.location.toString().replace(/&/g, "%26")
|
|
+ "&MMplayerType=" + ad + "&MMdoctitle=" + j.title;
|
|
if (typeof ab.flashvars != D) {
|
|
ab.flashvars += "&" + ac;
|
|
} else {
|
|
ab.flashvars = ac;
|
|
}
|
|
if (M.ie && M.win && ae.readyState != 4) {
|
|
var Y = C("div");
|
|
X += "SWFObjectNew";
|
|
Y.setAttribute("id", X);
|
|
ae.parentNode.insertBefore(Y, ae);
|
|
ae.style.display = "none";
|
|
(function() {
|
|
if (ae.readyState == 4) {
|
|
ae.parentNode.removeChild(ae);
|
|
} else {
|
|
setTimeout(arguments.callee, 10);
|
|
}
|
|
})();
|
|
}
|
|
u(aa, ab, X);
|
|
}
|
|
}
|
|
function p(Y) {
|
|
if (M.ie && M.win && Y.readyState != 4) {
|
|
var X = C("div");
|
|
Y.parentNode.insertBefore(X, Y);
|
|
X.parentNode.replaceChild(g(Y), X);
|
|
Y.style.display = "none";
|
|
(function() {
|
|
if (Y.readyState == 4) {
|
|
Y.parentNode.removeChild(Y);
|
|
} else {
|
|
setTimeout(arguments.callee, 10);
|
|
}
|
|
})();
|
|
} else {
|
|
Y.parentNode.replaceChild(g(Y), Y);
|
|
}
|
|
}
|
|
function g(ab) {
|
|
var aa = C("div");
|
|
if (M.win && M.ie) {
|
|
aa.innerHTML = ab.innerHTML;
|
|
} else {
|
|
var Y = ab.getElementsByTagName(r)[0];
|
|
if (Y) {
|
|
var ad = Y.childNodes;
|
|
if (ad) {
|
|
var X = ad.length;
|
|
for ( var Z = 0; Z < X; Z++) {
|
|
if (!(ad[Z].nodeType == 1 && ad[Z].nodeName == "PARAM")
|
|
&& !(ad[Z].nodeType == 8)) {
|
|
aa.appendChild(ad[Z].cloneNode(true));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return aa;
|
|
}
|
|
function u(ai, ag, Y) {
|
|
var X, aa = c(Y);
|
|
if (M.wk && M.wk < 312) {
|
|
return X;
|
|
}
|
|
if (aa) {
|
|
if (typeof ai.id == D) {
|
|
ai.id = Y;
|
|
}
|
|
if (M.ie && M.win) {
|
|
var ah = "";
|
|
for ( var ae in ai) {
|
|
if (ai[ae] != Object.prototype[ae]) {
|
|
if (ae.toLowerCase() == "data") {
|
|
ag.movie = ai[ae];
|
|
} else {
|
|
if (ae.toLowerCase() == "styleclass") {
|
|
ah += ' class="' + ai[ae] + '"';
|
|
} else {
|
|
if (ae.toLowerCase() != "classid") {
|
|
ah += " " + ae + '="' + ai[ae] + '"';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var af = "";
|
|
for ( var ad in ag) {
|
|
if (ag[ad] != Object.prototype[ad]) {
|
|
af += '<param name="' + ad + '" value="' + ag[ad]
|
|
+ '" />';
|
|
}
|
|
}
|
|
aa.outerHTML = '<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"'
|
|
+ ah + ">" + af + "</object>";
|
|
N[N.length] = ai.id;
|
|
X = c(ai.id);
|
|
} else {
|
|
var Z = C(r);
|
|
Z.setAttribute("type", q);
|
|
for ( var ac in ai) {
|
|
if (ai[ac] != Object.prototype[ac]) {
|
|
if (ac.toLowerCase() == "styleclass") {
|
|
Z.setAttribute("class", ai[ac]);
|
|
} else {
|
|
if (ac.toLowerCase() != "classid") {
|
|
Z.setAttribute(ac, ai[ac]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for ( var ab in ag) {
|
|
if (ag[ab] != Object.prototype[ab]
|
|
&& ab.toLowerCase() != "movie") {
|
|
e(Z, ab, ag[ab]);
|
|
}
|
|
}
|
|
aa.parentNode.replaceChild(Z, aa);
|
|
X = Z;
|
|
}
|
|
}
|
|
return X;
|
|
}
|
|
function e(Z, X, Y) {
|
|
var aa = C("param");
|
|
aa.setAttribute("name", X);
|
|
aa.setAttribute("value", Y);
|
|
Z.appendChild(aa);
|
|
}
|
|
function y(Y) {
|
|
var X = c(Y);
|
|
if (X && X.nodeName == "OBJECT") {
|
|
if (M.ie && M.win) {
|
|
X.style.display = "none";
|
|
(function() {
|
|
if (X.readyState == 4) {
|
|
b(Y);
|
|
} else {
|
|
setTimeout(arguments.callee, 10);
|
|
}
|
|
})();
|
|
} else {
|
|
X.parentNode.removeChild(X);
|
|
}
|
|
}
|
|
}
|
|
function b(Z) {
|
|
var Y = c(Z);
|
|
if (Y) {
|
|
for ( var X in Y) {
|
|
if (typeof Y[X] == "function") {
|
|
Y[X] = null;
|
|
}
|
|
}
|
|
Y.parentNode.removeChild(Y);
|
|
}
|
|
}
|
|
function c(Z) {
|
|
var X = null;
|
|
try {
|
|
X = j.getElementById(Z);
|
|
} catch (Y) {
|
|
}
|
|
return X;
|
|
}
|
|
function C(X) {
|
|
return j.createElement(X);
|
|
}
|
|
function i(Z, X, Y) {
|
|
Z.attachEvent(X, Y);
|
|
I[I.length] = [ Z, X, Y ];
|
|
}
|
|
function F(Z) {
|
|
var Y = M.pv, X = Z.split(".");
|
|
X[0] = parseInt(X[0], 10);
|
|
X[1] = parseInt(X[1], 10) || 0;
|
|
X[2] = parseInt(X[2], 10) || 0;
|
|
return (Y[0] > X[0] || (Y[0] == X[0] && Y[1] > X[1]) || (Y[0] == X[0]
|
|
&& Y[1] == X[1] && Y[2] >= X[2])) ? true : false;
|
|
}
|
|
function v(ac, Y, ad, ab) {
|
|
if (M.ie && M.mac) {
|
|
return;
|
|
}
|
|
var aa = j.getElementsByTagName("head")[0];
|
|
if (!aa) {
|
|
return;
|
|
}
|
|
var X = (ad && typeof ad == "string") ? ad : "screen";
|
|
if (ab) {
|
|
n = null;
|
|
G = null;
|
|
}
|
|
if (!n || G != X) {
|
|
var Z = C("style");
|
|
Z.setAttribute("type", "text/css");
|
|
Z.setAttribute("media", X);
|
|
n = aa.appendChild(Z);
|
|
if (M.ie && M.win && typeof j.styleSheets != D
|
|
&& j.styleSheets.length > 0) {
|
|
n = j.styleSheets[j.styleSheets.length - 1];
|
|
}
|
|
G = X;
|
|
}
|
|
if (M.ie && M.win) {
|
|
if (n && typeof n.addRule == r) {
|
|
n.addRule(ac, Y);
|
|
}
|
|
} else {
|
|
if (n && typeof j.createTextNode != D) {
|
|
n.appendChild(j.createTextNode(ac + " {" + Y + "}"));
|
|
}
|
|
}
|
|
}
|
|
function w(Z, X) {
|
|
if (!m) {
|
|
return;
|
|
}
|
|
var Y = X ? "visible" : "hidden";
|
|
if (J && c(Z)) {
|
|
c(Z).style.visibility = Y;
|
|
} else {
|
|
v("#" + Z, "visibility:" + Y);
|
|
}
|
|
}
|
|
function L(Y) {
|
|
var Z = /[\\\"<>\.;]/;
|
|
var X = Z.exec(Y) != null;
|
|
return X && typeof encodeURIComponent != D ? encodeURIComponent(Y) : Y;
|
|
}
|
|
var d = function() {
|
|
if (M.ie && M.win) {
|
|
window.attachEvent("onunload", function() {
|
|
var ac = I.length;
|
|
for ( var ab = 0; ab < ac; ab++) {
|
|
I[ab][0].detachEvent(I[ab][1], I[ab][2]);
|
|
}
|
|
var Z = N.length;
|
|
for ( var aa = 0; aa < Z; aa++) {
|
|
y(N[aa]);
|
|
}
|
|
for ( var Y in M) {
|
|
M[Y] = null;
|
|
}
|
|
M = null;
|
|
for ( var X in swfobject) {
|
|
swfobject[X] = null;
|
|
}
|
|
swfobject = null;
|
|
});
|
|
}
|
|
}();
|
|
return {
|
|
registerObject : function(ab, X, aa, Z) {
|
|
if (M.w3 && ab && X) {
|
|
var Y = {};
|
|
Y.id = ab;
|
|
Y.swfVersion = X;
|
|
Y.expressInstall = aa;
|
|
Y.callbackFn = Z;
|
|
o[o.length] = Y;
|
|
w(ab, false);
|
|
} else {
|
|
if (Z) {
|
|
Z({
|
|
success : false,
|
|
id : ab
|
|
});
|
|
}
|
|
}
|
|
},
|
|
getObjectById : function(X) {
|
|
if (M.w3) {
|
|
return z(X);
|
|
}
|
|
},
|
|
embedSWF : function(ab, ah, ae, ag, Y, aa, Z, ad, af, ac) {
|
|
var X = {
|
|
success : false,
|
|
id : ah
|
|
};
|
|
if (M.w3 && !(M.wk && M.wk < 312) && ab && ah && ae && ag && Y) {
|
|
w(ah, false);
|
|
K(function() {
|
|
ae += "";
|
|
ag += "";
|
|
var aj = {};
|
|
if (af && typeof af === r) {
|
|
for ( var al in af) {
|
|
aj[al] = af[al];
|
|
}
|
|
}
|
|
aj.data = ab;
|
|
aj.width = ae;
|
|
aj.height = ag;
|
|
var am = {};
|
|
if (ad && typeof ad === r) {
|
|
for ( var ak in ad) {
|
|
am[ak] = ad[ak];
|
|
}
|
|
}
|
|
if (Z && typeof Z === r) {
|
|
for ( var ai in Z) {
|
|
if (typeof am.flashvars != D) {
|
|
am.flashvars += "&" + ai + "=" + Z[ai];
|
|
} else {
|
|
am.flashvars = ai + "=" + Z[ai];
|
|
}
|
|
}
|
|
}
|
|
if (F(Y)) {
|
|
var an = u(aj, am, ah);
|
|
if (aj.id == ah) {
|
|
w(ah, true);
|
|
}
|
|
X.success = true;
|
|
X.ref = an;
|
|
} else {
|
|
if (aa && A()) {
|
|
aj.data = aa;
|
|
P(aj, am, ah, ac);
|
|
return;
|
|
} else {
|
|
w(ah, true);
|
|
}
|
|
}
|
|
if (ac) {
|
|
ac(X);
|
|
}
|
|
});
|
|
} else {
|
|
if (ac) {
|
|
ac(X);
|
|
}
|
|
}
|
|
},
|
|
switchOffAutoHideShow : function() {
|
|
m = false;
|
|
},
|
|
ua : M,
|
|
getFlashPlayerVersion : function() {
|
|
return {
|
|
major : M.pv[0],
|
|
minor : M.pv[1],
|
|
release : M.pv[2]
|
|
};
|
|
},
|
|
hasFlashPlayerVersion : F,
|
|
createSWF : function(Z, Y, X) {
|
|
if (M.w3) {
|
|
return u(Z, Y, X);
|
|
} else {
|
|
return undefined;
|
|
}
|
|
},
|
|
showExpressInstall : function(Z, aa, X, Y) {
|
|
if (M.w3 && A()) {
|
|
P(Z, aa, X, Y);
|
|
}
|
|
},
|
|
removeSWF : function(X) {
|
|
if (M.w3) {
|
|
y(X);
|
|
}
|
|
},
|
|
createCSS : function(aa, Z, Y, X) {
|
|
if (M.w3) {
|
|
v(aa, Z, Y, X);
|
|
}
|
|
},
|
|
addDomLoadEvent : K,
|
|
addLoadEvent : s,
|
|
getQueryParamValue : function(aa) {
|
|
var Z = j.location.search || j.location.hash;
|
|
if (Z) {
|
|
if (/\?/.test(Z)) {
|
|
Z = Z.split("?")[1];
|
|
}
|
|
if (aa == null) {
|
|
return L(Z);
|
|
}
|
|
var Y = Z.split("&");
|
|
for ( var X = 0; X < Y.length; X++) {
|
|
if (Y[X].substring(0, Y[X].indexOf("=")) == aa) {
|
|
return L(Y[X].substring((Y[X].indexOf("=") + 1)));
|
|
}
|
|
}
|
|
}
|
|
return "";
|
|
},
|
|
expressInstallCallback : function() {
|
|
if (a) {
|
|
var X = c(R);
|
|
if (X && l) {
|
|
X.parentNode.replaceChild(l, X);
|
|
if (Q) {
|
|
w(Q, true);
|
|
if (M.ie && M.win) {
|
|
l.style.display = "block";
|
|
}
|
|
}
|
|
if (E) {
|
|
E(B);
|
|
}
|
|
}
|
|
a = false;
|
|
}
|
|
}
|
|
};
|
|
}();
|
|
|
|
/*
|
|
* SWFUpload: http://www.swfupload.org, http://swfupload.googlecode.com
|
|
*
|
|
* mmSWFUpload 1.0: Flash upload dialog - http://profandesign.se/swfupload/,
|
|
* http://www.vinterwebb.se/
|
|
*
|
|
* SWFUpload is (c) 2006-2007 Lars Huring, Olov Nilzén and Mammon Media and is
|
|
* released under the MIT License:
|
|
* http://www.opensource.org/licenses/mit-license.php
|
|
*
|
|
* SWFUpload 2 is (c) 2007-2008 Jake Roberts and is released under the MIT
|
|
* License: http://www.opensource.org/licenses/mit-license.php
|
|
*/
|
|
|
|
var SWFUpload;
|
|
if (SWFUpload == undefined) {
|
|
SWFUpload = function(a) {
|
|
this.initSWFUpload(a)
|
|
}
|
|
}
|
|
SWFUpload.prototype.initSWFUpload = function(b) {
|
|
try {
|
|
this.customSettings = {};
|
|
this.settings = b;
|
|
this.eventQueue = [];
|
|
this.movieName = "SWFUpload_" + SWFUpload.movieCount++;
|
|
this.movieElement = null;
|
|
SWFUpload.instances[this.movieName] = this;
|
|
this.initSettings();
|
|
this.loadFlash();
|
|
this.displayDebugInfo()
|
|
} catch (a) {
|
|
delete SWFUpload.instances[this.movieName];
|
|
throw a
|
|
}
|
|
};
|
|
SWFUpload.instances = {};
|
|
SWFUpload.movieCount = 0;
|
|
SWFUpload.version = "2.2.0 2009-03-25";
|
|
SWFUpload.QUEUE_ERROR = {
|
|
QUEUE_LIMIT_EXCEEDED : -100,
|
|
FILE_EXCEEDS_SIZE_LIMIT : -110,
|
|
ZERO_BYTE_FILE : -120,
|
|
INVALID_FILETYPE : -130
|
|
};
|
|
SWFUpload.UPLOAD_ERROR = {
|
|
HTTP_ERROR : -200,
|
|
MISSING_UPLOAD_URL : -210,
|
|
IO_ERROR : -220,
|
|
SECURITY_ERROR : -230,
|
|
UPLOAD_LIMIT_EXCEEDED : -240,
|
|
UPLOAD_FAILED : -250,
|
|
SPECIFIED_FILE_ID_NOT_FOUND : -260,
|
|
FILE_VALIDATION_FAILED : -270,
|
|
FILE_CANCELLED : -280,
|
|
UPLOAD_STOPPED : -290
|
|
};
|
|
SWFUpload.FILE_STATUS = {
|
|
QUEUED : -1,
|
|
IN_PROGRESS : -2,
|
|
ERROR : -3,
|
|
COMPLETE : -4,
|
|
CANCELLED : -5
|
|
};
|
|
SWFUpload.BUTTON_ACTION = {
|
|
SELECT_FILE : -100,
|
|
SELECT_FILES : -110,
|
|
START_UPLOAD : -120
|
|
};
|
|
SWFUpload.CURSOR = {
|
|
ARROW : -1,
|
|
HAND : -2
|
|
};
|
|
SWFUpload.WINDOW_MODE = {
|
|
WINDOW : "window",
|
|
TRANSPARENT : "transparent",
|
|
OPAQUE : "opaque"
|
|
};
|
|
SWFUpload.completeURL = function(a) {
|
|
if (typeof (a) !== "string" || a.match(/^https?:\/\//i) || a.match(/^\//)) {
|
|
return a
|
|
}
|
|
var c = window.location.protocol + "//" + window.location.hostname
|
|
+ (window.location.port ? ":" + window.location.port : "");
|
|
var b = window.location.pathname.lastIndexOf("/");
|
|
if (b <= 0) {
|
|
path = "/"
|
|
} else {
|
|
path = window.location.pathname.substr(0, b) + "/"
|
|
}
|
|
return path + a
|
|
};
|
|
SWFUpload.prototype.initSettings = function() {
|
|
this.ensureDefault = function(b, a) {
|
|
this.settings[b] = (this.settings[b] == undefined) ? a
|
|
: this.settings[b]
|
|
};
|
|
this.ensureDefault("upload_url", "");
|
|
this.ensureDefault("preserve_relative_urls", false);
|
|
this.ensureDefault("file_post_name", "Filedata");
|
|
this.ensureDefault("post_params", {});
|
|
this.ensureDefault("use_query_string", false);
|
|
this.ensureDefault("requeue_on_error", false);
|
|
this.ensureDefault("http_success", []);
|
|
this.ensureDefault("assume_success_timeout", 0);
|
|
this.ensureDefault("file_types", "*.*");
|
|
this.ensureDefault("file_types_description", "All Files");
|
|
this.ensureDefault("file_size_limit", 0);
|
|
this.ensureDefault("file_upload_limit", 0);
|
|
this.ensureDefault("file_queue_limit", 0);
|
|
this.ensureDefault("flash_url", "swfupload.swf");
|
|
this.ensureDefault("prevent_swf_caching", true);
|
|
this.ensureDefault("button_image_url", "");
|
|
this.ensureDefault("button_width", 1);
|
|
this.ensureDefault("button_height", 1);
|
|
this.ensureDefault("button_text", "");
|
|
this.ensureDefault("button_text_style", "color: #000000; font-size: 16pt;");
|
|
this.ensureDefault("button_text_top_padding", 0);
|
|
this.ensureDefault("button_text_left_padding", 0);
|
|
this.ensureDefault("button_action", SWFUpload.BUTTON_ACTION.SELECT_FILES);
|
|
this.ensureDefault("button_disabled", false);
|
|
this.ensureDefault("button_placeholder_id", "");
|
|
this.ensureDefault("button_placeholder", null);
|
|
this.ensureDefault("button_cursor", SWFUpload.CURSOR.ARROW);
|
|
this.ensureDefault("button_window_mode", SWFUpload.WINDOW_MODE.WINDOW);
|
|
this.ensureDefault("debug", false);
|
|
this.settings.debug_enabled = this.settings.debug;
|
|
this.settings.return_upload_start_handler = this.returnUploadStart;
|
|
this.ensureDefault("swfupload_loaded_handler", null);
|
|
this.ensureDefault("file_dialog_start_handler", null);
|
|
this.ensureDefault("file_queued_handler", null);
|
|
this.ensureDefault("file_queue_error_handler", null);
|
|
this.ensureDefault("file_dialog_complete_handler", null);
|
|
this.ensureDefault("upload_start_handler", null);
|
|
this.ensureDefault("upload_progress_handler", null);
|
|
this.ensureDefault("upload_error_handler", null);
|
|
this.ensureDefault("upload_success_handler", null);
|
|
this.ensureDefault("upload_complete_handler", null);
|
|
this.ensureDefault("debug_handler", this.debugMessage);
|
|
this.ensureDefault("custom_settings", {});
|
|
this.customSettings = this.settings.custom_settings;
|
|
if (!!this.settings.prevent_swf_caching) {
|
|
this.settings.flash_url = this.settings.flash_url
|
|
+ (this.settings.flash_url.indexOf("?") < 0 ? "?" : "&")
|
|
+ "preventswfcaching=" + new Date().getTime()
|
|
}
|
|
if (!this.settings.preserve_relative_urls) {
|
|
this.settings.upload_url = SWFUpload
|
|
.completeURL(this.settings.upload_url);
|
|
this.settings.button_image_url = SWFUpload
|
|
.completeURL(this.settings.button_image_url)
|
|
}
|
|
delete this.ensureDefault
|
|
};
|
|
SWFUpload.prototype.loadFlash = function() {
|
|
var a, b;
|
|
if (document.getElementById(this.movieName) !== null) {
|
|
throw "ID " + this.movieName
|
|
+ " is already in use. The Flash Object could not be added"
|
|
}
|
|
a = document.getElementById(this.settings.button_placeholder_id)
|
|
|| this.settings.button_placeholder;
|
|
if (a == undefined) {
|
|
throw "Could not find the placeholder element: "
|
|
+ this.settings.button_placeholder_id
|
|
}
|
|
b = document.createElement("div");
|
|
b.innerHTML = this.getFlashHTML();
|
|
a.parentNode.replaceChild(b.firstChild, a);
|
|
if (window[this.movieName] == undefined) {
|
|
window[this.movieName] = this.getMovieElement()
|
|
}
|
|
};
|
|
SWFUpload.prototype.getFlashHTML = function() {
|
|
return [ '<object id="', this.movieName,
|
|
'" type="application/x-shockwave-flash" data="',
|
|
this.settings.flash_url, '" width="', this.settings.button_width,
|
|
'" height="', this.settings.button_height, '" class="swfupload">',
|
|
'<param name="wmode" value="', this.settings.button_window_mode,
|
|
'" />', '<param name="movie" value="', this.settings.flash_url,
|
|
'" />', '<param name="quality" value="high" />',
|
|
'<param name="menu" value="false" />',
|
|
'<param name="allowScriptAccess" value="always" />',
|
|
'<param name="flashvars" value="' + this.getFlashVars() + '" />',
|
|
"</object>" ].join("")
|
|
};
|
|
SWFUpload.prototype.getFlashVars = function() {
|
|
var b = this.buildParamString();
|
|
var a = this.settings.http_success.join(",");
|
|
return [ "movieName=", encodeURIComponent(this.movieName),
|
|
"&uploadURL=", encodeURIComponent(this.settings.upload_url),
|
|
"&useQueryString=",
|
|
encodeURIComponent(this.settings.use_query_string),
|
|
"&requeueOnError=",
|
|
encodeURIComponent(this.settings.requeue_on_error),
|
|
"&httpSuccess=", encodeURIComponent(a),
|
|
"&assumeSuccessTimeout=",
|
|
encodeURIComponent(this.settings.assume_success_timeout),
|
|
"&params=", encodeURIComponent(b), "&filePostName=",
|
|
encodeURIComponent(this.settings.file_post_name),
|
|
"&fileTypes=", encodeURIComponent(this.settings.file_types),
|
|
"&fileTypesDescription=",
|
|
encodeURIComponent(this.settings.file_types_description),
|
|
"&fileSizeLimit=",
|
|
encodeURIComponent(this.settings.file_size_limit),
|
|
"&fileUploadLimit=",
|
|
encodeURIComponent(this.settings.file_upload_limit),
|
|
"&fileQueueLimit=",
|
|
encodeURIComponent(this.settings.file_queue_limit),
|
|
"&debugEnabled=",
|
|
encodeURIComponent(this.settings.debug_enabled),
|
|
"&buttonImageURL=",
|
|
encodeURIComponent(this.settings.button_image_url),
|
|
"&buttonWidth=",
|
|
encodeURIComponent(this.settings.button_width),
|
|
"&buttonHeight=",
|
|
encodeURIComponent(this.settings.button_height),
|
|
"&buttonText=", encodeURIComponent(this.settings.button_text),
|
|
"&buttonTextTopPadding=",
|
|
encodeURIComponent(this.settings.button_text_top_padding),
|
|
"&buttonTextLeftPadding=",
|
|
encodeURIComponent(this.settings.button_text_left_padding),
|
|
"&buttonTextStyle=",
|
|
encodeURIComponent(this.settings.button_text_style),
|
|
"&buttonAction=",
|
|
encodeURIComponent(this.settings.button_action),
|
|
"&buttonDisabled=",
|
|
encodeURIComponent(this.settings.button_disabled),
|
|
"&buttonCursor=",
|
|
encodeURIComponent(this.settings.button_cursor) ].join("")
|
|
};
|
|
SWFUpload.prototype.getMovieElement = function() {
|
|
if (this.movieElement == undefined) {
|
|
this.movieElement = document.getElementById(this.movieName)
|
|
}
|
|
if (this.movieElement === null) {
|
|
throw "Could not find Flash element"
|
|
}
|
|
return this.movieElement
|
|
};
|
|
SWFUpload.prototype.buildParamString = function() {
|
|
var c = this.settings.post_params;
|
|
var b = [];
|
|
if (typeof (c) === "object") {
|
|
for ( var a in c) {
|
|
if (c.hasOwnProperty(a)) {
|
|
b.push(encodeURIComponent(a.toString()) + "="
|
|
+ encodeURIComponent(c[a].toString()))
|
|
}
|
|
}
|
|
}
|
|
return b.join("&")
|
|
};
|
|
SWFUpload.prototype.destroy = function() {
|
|
try {
|
|
this.cancelUpload(null, false);
|
|
var a = null;
|
|
a = this.getMovieElement();
|
|
if (a && typeof (a.CallFunction) === "unknown") {
|
|
for ( var c in a) {
|
|
try {
|
|
if (typeof (a[c]) === "function") {
|
|
a[c] = null
|
|
}
|
|
} catch (e) {
|
|
}
|
|
}
|
|
try {
|
|
a.parentNode.removeChild(a)
|
|
} catch (b) {
|
|
}
|
|
}
|
|
window[this.movieName] = null;
|
|
SWFUpload.instances[this.movieName] = null;
|
|
delete SWFUpload.instances[this.movieName];
|
|
this.movieElement = null;
|
|
this.settings = null;
|
|
this.customSettings = null;
|
|
this.eventQueue = null;
|
|
this.movieName = null;
|
|
return true
|
|
} catch (d) {
|
|
return false
|
|
}
|
|
};
|
|
SWFUpload.prototype.displayDebugInfo = function() {
|
|
this.debug([
|
|
"---SWFUpload Instance Info---\n",
|
|
"Version: ",
|
|
SWFUpload.version,
|
|
"\n",
|
|
"Movie Name: ",
|
|
this.movieName,
|
|
"\n",
|
|
"Settings:\n",
|
|
"\t",
|
|
"upload_url: ",
|
|
this.settings.upload_url,
|
|
"\n",
|
|
"\t",
|
|
"flash_url: ",
|
|
this.settings.flash_url,
|
|
"\n",
|
|
"\t",
|
|
"use_query_string: ",
|
|
this.settings.use_query_string.toString(),
|
|
"\n",
|
|
"\t",
|
|
"requeue_on_error: ",
|
|
this.settings.requeue_on_error.toString(),
|
|
"\n",
|
|
"\t",
|
|
"http_success: ",
|
|
this.settings.http_success.join(", "),
|
|
"\n",
|
|
"\t",
|
|
"assume_success_timeout: ",
|
|
this.settings.assume_success_timeout,
|
|
"\n",
|
|
"\t",
|
|
"file_post_name: ",
|
|
this.settings.file_post_name,
|
|
"\n",
|
|
"\t",
|
|
"post_params: ",
|
|
this.settings.post_params.toString(),
|
|
"\n",
|
|
"\t",
|
|
"file_types: ",
|
|
this.settings.file_types,
|
|
"\n",
|
|
"\t",
|
|
"file_types_description: ",
|
|
this.settings.file_types_description,
|
|
"\n",
|
|
"\t",
|
|
"file_size_limit: ",
|
|
this.settings.file_size_limit,
|
|
"\n",
|
|
"\t",
|
|
"file_upload_limit: ",
|
|
this.settings.file_upload_limit,
|
|
"\n",
|
|
"\t",
|
|
"file_queue_limit: ",
|
|
this.settings.file_queue_limit,
|
|
"\n",
|
|
"\t",
|
|
"debug: ",
|
|
this.settings.debug.toString(),
|
|
"\n",
|
|
"\t",
|
|
"prevent_swf_caching: ",
|
|
this.settings.prevent_swf_caching.toString(),
|
|
"\n",
|
|
"\t",
|
|
"button_placeholder_id: ",
|
|
this.settings.button_placeholder_id.toString(),
|
|
"\n",
|
|
"\t",
|
|
"button_placeholder: ",
|
|
(this.settings.button_placeholder ? "Set" : "Not Set"),
|
|
"\n",
|
|
"\t",
|
|
"button_image_url: ",
|
|
this.settings.button_image_url.toString(),
|
|
"\n",
|
|
"\t",
|
|
"button_width: ",
|
|
this.settings.button_width.toString(),
|
|
"\n",
|
|
"\t",
|
|
"button_height: ",
|
|
this.settings.button_height.toString(),
|
|
"\n",
|
|
"\t",
|
|
"button_text: ",
|
|
this.settings.button_text.toString(),
|
|
"\n",
|
|
"\t",
|
|
"button_text_style: ",
|
|
this.settings.button_text_style.toString(),
|
|
"\n",
|
|
"\t",
|
|
"button_text_top_padding: ",
|
|
this.settings.button_text_top_padding.toString(),
|
|
"\n",
|
|
"\t",
|
|
"button_text_left_padding: ",
|
|
this.settings.button_text_left_padding.toString(),
|
|
"\n",
|
|
"\t",
|
|
"button_action: ",
|
|
this.settings.button_action.toString(),
|
|
"\n",
|
|
"\t",
|
|
"button_disabled: ",
|
|
this.settings.button_disabled.toString(),
|
|
"\n",
|
|
"\t",
|
|
"custom_settings: ",
|
|
this.settings.custom_settings.toString(),
|
|
"\n",
|
|
"Event Handlers:\n",
|
|
"\t",
|
|
"swfupload_loaded_handler assigned: ",
|
|
(typeof this.settings.swfupload_loaded_handler === "function")
|
|
.toString(),
|
|
"\n",
|
|
"\t",
|
|
"file_dialog_start_handler assigned: ",
|
|
(typeof this.settings.file_dialog_start_handler === "function")
|
|
.toString(),
|
|
"\n",
|
|
"\t",
|
|
"file_queued_handler assigned: ",
|
|
(typeof this.settings.file_queued_handler === "function")
|
|
.toString(),
|
|
"\n",
|
|
"\t",
|
|
"file_queue_error_handler assigned: ",
|
|
(typeof this.settings.file_queue_error_handler === "function")
|
|
.toString(),
|
|
"\n",
|
|
"\t",
|
|
"upload_start_handler assigned: ",
|
|
(typeof this.settings.upload_start_handler === "function")
|
|
.toString(),
|
|
"\n",
|
|
"\t",
|
|
"upload_progress_handler assigned: ",
|
|
(typeof this.settings.upload_progress_handler === "function")
|
|
.toString(),
|
|
"\n",
|
|
"\t",
|
|
"upload_error_handler assigned: ",
|
|
(typeof this.settings.upload_error_handler === "function")
|
|
.toString(),
|
|
"\n",
|
|
"\t",
|
|
"upload_success_handler assigned: ",
|
|
(typeof this.settings.upload_success_handler === "function")
|
|
.toString(),
|
|
"\n",
|
|
"\t",
|
|
"upload_complete_handler assigned: ",
|
|
(typeof this.settings.upload_complete_handler === "function")
|
|
.toString(), "\n", "\t",
|
|
"debug_handler assigned: ",
|
|
(typeof this.settings.debug_handler === "function").toString(),
|
|
"\n" ].join(""))
|
|
};
|
|
SWFUpload.prototype.addSetting = function(b, c, a) {
|
|
if (c == undefined) {
|
|
return (this.settings[b] = a)
|
|
} else {
|
|
return (this.settings[b] = c)
|
|
}
|
|
};
|
|
SWFUpload.prototype.getSetting = function(a) {
|
|
if (this.settings[a] != undefined) {
|
|
return this.settings[a]
|
|
}
|
|
return ""
|
|
};
|
|
SWFUpload.prototype.callFlash = function(functionName, argumentArray) {
|
|
argumentArray = argumentArray || [];
|
|
var movieElement = this.getMovieElement();
|
|
var returnValue, returnString;
|
|
try {
|
|
returnString = movieElement.CallFunction('<invoke name="'
|
|
+ functionName + '" returntype="javascript">'
|
|
+ __flash__argumentsToXML(argumentArray, 0) + "</invoke>");
|
|
returnValue = eval(returnString)
|
|
} catch (ex) {
|
|
throw "Call to " + functionName + " failed"
|
|
}
|
|
if (returnValue != undefined && typeof returnValue.post === "object") {
|
|
returnValue = this.unescapeFilePostParams(returnValue)
|
|
}
|
|
return returnValue
|
|
};
|
|
SWFUpload.prototype.selectFile = function() {
|
|
this.callFlash("SelectFile")
|
|
};
|
|
SWFUpload.prototype.selectFiles = function() {
|
|
this.callFlash("SelectFiles")
|
|
};
|
|
SWFUpload.prototype.startUpload = function(a) {
|
|
this.callFlash("StartUpload", [ a ])
|
|
};
|
|
SWFUpload.prototype.cancelUpload = function(a, b) {
|
|
if (b !== false) {
|
|
b = true
|
|
}
|
|
this.callFlash("CancelUpload", [ a, b ])
|
|
};
|
|
SWFUpload.prototype.stopUpload = function() {
|
|
this.callFlash("StopUpload")
|
|
};
|
|
SWFUpload.prototype.getStats = function() {
|
|
return this.callFlash("GetStats")
|
|
};
|
|
SWFUpload.prototype.setStats = function(a) {
|
|
this.callFlash("SetStats", [ a ])
|
|
};
|
|
SWFUpload.prototype.getFile = function(a) {
|
|
if (typeof (a) === "number") {
|
|
return this.callFlash("GetFileByIndex", [ a ])
|
|
} else {
|
|
return this.callFlash("GetFile", [ a ])
|
|
}
|
|
};
|
|
SWFUpload.prototype.addFileParam = function(a, b, c) {
|
|
return this.callFlash("AddFileParam", [ a, b, c ])
|
|
};
|
|
SWFUpload.prototype.removeFileParam = function(a, b) {
|
|
this.callFlash("RemoveFileParam", [ a, b ])
|
|
};
|
|
SWFUpload.prototype.setUploadURL = function(a) {
|
|
this.settings.upload_url = a.toString();
|
|
this.callFlash("SetUploadURL", [ a ])
|
|
};
|
|
SWFUpload.prototype.setPostParams = function(a) {
|
|
this.settings.post_params = a;
|
|
this.callFlash("SetPostParams", [ a ])
|
|
};
|
|
SWFUpload.prototype.addPostParam = function(a, b) {
|
|
this.settings.post_params[a] = b;
|
|
this.callFlash("SetPostParams", [ this.settings.post_params ])
|
|
};
|
|
SWFUpload.prototype.removePostParam = function(a) {
|
|
delete this.settings.post_params[a];
|
|
this.callFlash("SetPostParams", [ this.settings.post_params ])
|
|
};
|
|
SWFUpload.prototype.setFileTypes = function(a, b) {
|
|
this.settings.file_types = a;
|
|
this.settings.file_types_description = b;
|
|
this.callFlash("SetFileTypes", [ a, b ])
|
|
};
|
|
SWFUpload.prototype.setFileSizeLimit = function(a) {
|
|
this.settings.file_size_limit = a;
|
|
this.callFlash("SetFileSizeLimit", [ a ])
|
|
};
|
|
SWFUpload.prototype.setFileUploadLimit = function(a) {
|
|
this.settings.file_upload_limit = a;
|
|
this.callFlash("SetFileUploadLimit", [ a ])
|
|
};
|
|
SWFUpload.prototype.setFileQueueLimit = function(a) {
|
|
this.settings.file_queue_limit = a;
|
|
this.callFlash("SetFileQueueLimit", [ a ])
|
|
};
|
|
SWFUpload.prototype.setFilePostName = function(a) {
|
|
this.settings.file_post_name = a;
|
|
this.callFlash("SetFilePostName", [ a ])
|
|
};
|
|
SWFUpload.prototype.setUseQueryString = function(a) {
|
|
this.settings.use_query_string = a;
|
|
this.callFlash("SetUseQueryString", [ a ])
|
|
};
|
|
SWFUpload.prototype.setRequeueOnError = function(a) {
|
|
this.settings.requeue_on_error = a;
|
|
this.callFlash("SetRequeueOnError", [ a ])
|
|
};
|
|
SWFUpload.prototype.setHTTPSuccess = function(a) {
|
|
if (typeof a === "string") {
|
|
a = a.replace(" ", "").split(",")
|
|
}
|
|
this.settings.http_success = a;
|
|
this.callFlash("SetHTTPSuccess", [ a ])
|
|
};
|
|
SWFUpload.prototype.setAssumeSuccessTimeout = function(a) {
|
|
this.settings.assume_success_timeout = a;
|
|
this.callFlash("SetAssumeSuccessTimeout", [ a ])
|
|
};
|
|
SWFUpload.prototype.setDebugEnabled = function(a) {
|
|
this.settings.debug_enabled = a;
|
|
this.callFlash("SetDebugEnabled", [ a ])
|
|
};
|
|
SWFUpload.prototype.setButtonImageURL = function(a) {
|
|
if (a == undefined) {
|
|
a = ""
|
|
}
|
|
this.settings.button_image_url = a;
|
|
this.callFlash("SetButtonImageURL", [ a ])
|
|
};
|
|
SWFUpload.prototype.setButtonDimensions = function(c, a) {
|
|
this.settings.button_width = c;
|
|
this.settings.button_height = a;
|
|
var b = this.getMovieElement();
|
|
if (b != undefined) {
|
|
b.style.width = c + "px";
|
|
b.style.height = a + "px"
|
|
}
|
|
this.callFlash("SetButtonDimensions", [ c, a ])
|
|
};
|
|
SWFUpload.prototype.setButtonText = function(a) {
|
|
this.settings.button_text = a;
|
|
this.callFlash("SetButtonText", [ a ])
|
|
};
|
|
SWFUpload.prototype.setButtonTextPadding = function(b, a) {
|
|
this.settings.button_text_top_padding = a;
|
|
this.settings.button_text_left_padding = b;
|
|
this.callFlash("SetButtonTextPadding", [ b, a ])
|
|
};
|
|
SWFUpload.prototype.setButtonTextStyle = function(a) {
|
|
this.settings.button_text_style = a;
|
|
this.callFlash("SetButtonTextStyle", [ a ])
|
|
};
|
|
SWFUpload.prototype.setButtonDisabled = function(a) {
|
|
this.settings.button_disabled = a;
|
|
this.callFlash("SetButtonDisabled", [ a ])
|
|
};
|
|
SWFUpload.prototype.setButtonAction = function(a) {
|
|
this.settings.button_action = a;
|
|
this.callFlash("SetButtonAction", [ a ])
|
|
};
|
|
SWFUpload.prototype.setButtonCursor = function(a) {
|
|
this.settings.button_cursor = a;
|
|
this.callFlash("SetButtonCursor", [ a ])
|
|
};
|
|
SWFUpload.prototype.queueEvent = function(b, c) {
|
|
if (c == undefined) {
|
|
c = []
|
|
} else {
|
|
if (!(c instanceof Array)) {
|
|
c = [ c ]
|
|
}
|
|
}
|
|
var a = this;
|
|
if (typeof this.settings[b] === "function") {
|
|
this.eventQueue.push(function() {
|
|
this.settings[b].apply(this, c)
|
|
});
|
|
setTimeout(function() {
|
|
a.executeNextEvent()
|
|
}, 0)
|
|
} else {
|
|
if (this.settings[b] !== null) {
|
|
throw "Event handler " + b + " is unknown or is not a function"
|
|
}
|
|
}
|
|
};
|
|
SWFUpload.prototype.executeNextEvent = function() {
|
|
var a = this.eventQueue ? this.eventQueue.shift() : null;
|
|
if (typeof (a) === "function") {
|
|
a.apply(this)
|
|
}
|
|
};
|
|
SWFUpload.prototype.unescapeFilePostParams = function(c) {
|
|
var e = /[$]([0-9a-f]{4})/i;
|
|
var f = {};
|
|
var d;
|
|
if (c != undefined) {
|
|
for ( var a in c.post) {
|
|
if (c.post.hasOwnProperty(a)) {
|
|
d = a;
|
|
var b;
|
|
while ((b = e.exec(d)) !== null) {
|
|
d = d.replace(b[0], String.fromCharCode(parseInt("0x"
|
|
+ b[1], 16)))
|
|
}
|
|
f[d] = c.post[a]
|
|
}
|
|
}
|
|
c.post = f
|
|
}
|
|
return c
|
|
};
|
|
SWFUpload.prototype.testExternalInterface = function() {
|
|
try {
|
|
return this.callFlash("TestExternalInterface")
|
|
} catch (a) {
|
|
return false
|
|
}
|
|
};
|
|
SWFUpload.prototype.flashReady = function() {
|
|
var a = this.getMovieElement();
|
|
if (!a) {
|
|
this
|
|
.debug("Flash called back ready but the flash movie can't be found.");
|
|
return
|
|
}
|
|
this.cleanUp(a);
|
|
this.queueEvent("swfupload_loaded_handler")
|
|
};
|
|
SWFUpload.prototype.cleanUp = function(a) {
|
|
try {
|
|
if (this.movieElement && typeof (a.CallFunction) === "unknown") {
|
|
this
|
|
.debug("Removing Flash functions hooks (this should only run in IE and should prevent memory leaks)");
|
|
for ( var c in a) {
|
|
try {
|
|
if (typeof (a[c]) === "function") {
|
|
a[c] = null
|
|
}
|
|
} catch (b) {
|
|
}
|
|
}
|
|
}
|
|
} catch (d) {
|
|
}
|
|
window.__flash__removeCallback = function(e, f) {
|
|
try {
|
|
if (e) {
|
|
e[f] = null
|
|
}
|
|
} catch (g) {
|
|
}
|
|
}
|
|
};
|
|
SWFUpload.prototype.fileDialogStart = function() {
|
|
this.queueEvent("file_dialog_start_handler")
|
|
};
|
|
SWFUpload.prototype.fileQueued = function(a) {
|
|
a = this.unescapeFilePostParams(a);
|
|
this.queueEvent("file_queued_handler", a)
|
|
};
|
|
SWFUpload.prototype.fileQueueError = function(a, c, b) {
|
|
a = this.unescapeFilePostParams(a);
|
|
this.queueEvent("file_queue_error_handler", [ a, c, b ])
|
|
};
|
|
SWFUpload.prototype.fileDialogComplete = function(b, c, a) {
|
|
this.queueEvent("file_dialog_complete_handler", [ b, c, a ])
|
|
};
|
|
SWFUpload.prototype.uploadStart = function(a) {
|
|
a = this.unescapeFilePostParams(a);
|
|
this.queueEvent("return_upload_start_handler", a)
|
|
};
|
|
SWFUpload.prototype.returnUploadStart = function(a) {
|
|
var b;
|
|
if (typeof this.settings.upload_start_handler === "function") {
|
|
a = this.unescapeFilePostParams(a);
|
|
b = this.settings.upload_start_handler.call(this, a)
|
|
} else {
|
|
if (this.settings.upload_start_handler != undefined) {
|
|
throw "upload_start_handler must be a function"
|
|
}
|
|
}
|
|
if (b === undefined) {
|
|
b = true
|
|
}
|
|
b = !!b;
|
|
this.callFlash("ReturnUploadStart", [ b ])
|
|
};
|
|
SWFUpload.prototype.uploadProgress = function(a, c, b) {
|
|
a = this.unescapeFilePostParams(a);
|
|
this.queueEvent("upload_progress_handler", [ a, c, b ])
|
|
};
|
|
SWFUpload.prototype.uploadError = function(a, c, b) {
|
|
a = this.unescapeFilePostParams(a);
|
|
this.queueEvent("upload_error_handler", [ a, c, b ])
|
|
};
|
|
SWFUpload.prototype.uploadSuccess = function(b, a, c) {
|
|
b = this.unescapeFilePostParams(b);
|
|
this.queueEvent("upload_success_handler", [ b, a, c ])
|
|
};
|
|
SWFUpload.prototype.uploadComplete = function(a) {
|
|
a = this.unescapeFilePostParams(a);
|
|
this.queueEvent("upload_complete_handler", a)
|
|
};
|
|
SWFUpload.prototype.debug = function(a) {
|
|
this.queueEvent("debug_handler", a)
|
|
};
|
|
SWFUpload.prototype.debugMessage = function(c) {
|
|
if (this.settings.debug) {
|
|
var a, d = [];
|
|
if (typeof c === "object" && typeof c.name === "string"
|
|
&& typeof c.message === "string") {
|
|
for ( var b in c) {
|
|
if (c.hasOwnProperty(b)) {
|
|
d.push(b + ": " + c[b])
|
|
}
|
|
}
|
|
a = d.join("\n") || "";
|
|
d = a.split("\n");
|
|
a = "EXCEPTION: " + d.join("\nEXCEPTION: ");
|
|
SWFUpload.Console.writeLine(a)
|
|
} else {
|
|
SWFUpload.Console.writeLine(c)
|
|
}
|
|
}
|
|
};
|
|
SWFUpload.Console = {};
|
|
SWFUpload.Console.writeLine = function(d) {
|
|
var b, a;
|
|
try {
|
|
b = document.getElementById("SWFUpload_Console");
|
|
if (!b) {
|
|
a = document.createElement("form");
|
|
document.getElementsByTagName("body")[0].appendChild(a);
|
|
b = document.createElement("textarea");
|
|
b.id = "SWFUpload_Console";
|
|
b.style.fontFamily = "monospace";
|
|
b.setAttribute("wrap", "off");
|
|
b.wrap = "off";
|
|
b.style.overflow = "auto";
|
|
b.style.width = "700px";
|
|
b.style.height = "350px";
|
|
b.style.margin = "5px";
|
|
a.appendChild(b)
|
|
}
|
|
b.value += d + "\n";
|
|
b.scrollTop = b.scrollHeight - b.clientHeight
|
|
} catch (c) {
|
|
alert("Exception: " + c.name + " Message: " + c.message)
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Uploadify v3.1.1 Copyright (c) 2012 Reactive Apps, Ronnie Garcia Released
|
|
* under the MIT License <http://www.opensource.org/licenses/mit-license.php>
|
|
*/
|
|
|
|
(function($) {
|
|
|
|
// These methods can be called by adding them as the first argument in the
|
|
// uploadify plugin call
|
|
var methods = {
|
|
|
|
init : function(options, swfUploadOptions) {
|
|
|
|
return this
|
|
.each(function() {
|
|
|
|
// Create a reference to the jQuery DOM object
|
|
var $this = $(this);
|
|
|
|
// Clone the original DOM object
|
|
var $clone = $this.clone();
|
|
|
|
// Setup the default options
|
|
var settings = $.extend({
|
|
// Required Settings
|
|
id : $this.attr('id'), // The ID of the DOM object
|
|
swf : 'uploadify.swf', // The path to the uploadify
|
|
// SWF file
|
|
uploader : 'uploadify.php', // The path to the
|
|
// server-side upload
|
|
// script
|
|
|
|
// Options
|
|
auto : true, // Automatically upload files when
|
|
// added to the queue
|
|
buttonClass : '', // A class name to add to the
|
|
// browse button DOM object
|
|
buttonCursor : 'hand', // The cursor to use with
|
|
// the browse button
|
|
buttonImage : null, // (String or null) The path to
|
|
// an image to use for the Flash
|
|
// browse button if not using
|
|
// CSS to style the button
|
|
buttonText : 'SELECT FILES', // The text to use
|
|
// for the browse
|
|
// button
|
|
checkExisting : false, // The path to a server-side
|
|
// script that checks for
|
|
// existing files on the
|
|
// server
|
|
debug : false, // Turn on swfUpload debugging mode
|
|
fileObjName : 'Filedata', // The name of the file
|
|
// object to use in your
|
|
// server-side script
|
|
fileSizeLimit : 0, // The maximum size of an
|
|
// uploadable file in KB
|
|
// (Accepts units B KB MB GB if
|
|
// string, 0 for no limit)
|
|
fileTypeDesc : 'All Files', // The description for
|
|
// file types in the
|
|
// browse dialog
|
|
fileTypeExts : '*.*', // Allowed extensions in the
|
|
// browse dialog
|
|
// (server-side validation
|
|
// should also be used)
|
|
height : 30, // The height of the browse button
|
|
method : 'post', // The method to use when
|
|
// sending files to the
|
|
// server-side upload script
|
|
multi : true, // Allow multiple file selection in
|
|
// the browse dialog
|
|
formData : {}, // An object with additional data to
|
|
// send to the server-side upload
|
|
// script with every file upload
|
|
preventCaching : true, // Adds a random value to
|
|
// the Flash URL to prevent
|
|
// caching of it (conflicts
|
|
// with existing parameters)
|
|
progressData : 'percentage', // ('percentage' or
|
|
// 'speed') Data to
|
|
// show in the queue
|
|
// item during a
|
|
// file upload
|
|
queueID : false, // The ID of the DOM object to
|
|
// use as a file queue (without
|
|
// the #)
|
|
queueSizeLimit : 999, // The maximum number of
|
|
// files that can be in the
|
|
// queue at one time
|
|
removeCompleted : true, // Remove queue items from
|
|
// the queue when they are
|
|
// done uploading
|
|
removeTimeout : 3, // The delay in seconds before
|
|
// removing a queue item if
|
|
// removeCompleted is set to
|
|
// true
|
|
requeueErrors : false, // Keep errored files in the
|
|
// queue and keep trying to
|
|
// upload them
|
|
successTimeout : 30, // The number of seconds to
|
|
// wait for Flash to detect
|
|
// the server's response
|
|
// after the file has
|
|
// finished uploading
|
|
uploadLimit : 0, // The maximum number of files
|
|
// you can upload
|
|
width : 120, // The width of the browse button
|
|
|
|
// Events
|
|
overrideEvents : []
|
|
// (Array) A list of default event handlers to skip
|
|
/*
|
|
* onCancel // Triggered when a file is cancelled from
|
|
* the queue onClearQueue // Triggered during the 'clear
|
|
* queue' method onDestroy // Triggered when the
|
|
* uploadify object is destroyed onDialogClose //
|
|
* Triggered when the browse dialog is closed
|
|
* onDialogOpen // Triggered when the browse dialog is
|
|
* opened onDisable // Triggered when the browse button
|
|
* gets disabled onEnable // Triggered when the browse
|
|
* button gets enabled onFallback // Triggered is Flash
|
|
* is not detected onInit // Triggered when Uploadify is
|
|
* initialized onQueueComplete // Triggered when all
|
|
* files in the queue have been uploaded onSelectError //
|
|
* Triggered when an error occurs while selecting a file
|
|
* (file size, queue size limit, etc.) onSelect //
|
|
* Triggered for each file that is selected onSWFReady //
|
|
* Triggered when the SWF button is loaded
|
|
* onUploadComplete // Triggered when a file upload
|
|
* completes (success or error) onUploadError //
|
|
* Triggered when a file upload returns an error
|
|
* onUploadSuccess // Triggered when a file is uploaded
|
|
* successfully onUploadProgress // Triggered every time
|
|
* a file progress is updated onUploadStart // Triggered
|
|
* immediately before a file upload starts
|
|
*/
|
|
}, options);
|
|
|
|
// Prepare settings for SWFUpload
|
|
var swfUploadSettings = {
|
|
assume_success_timeout : settings.successTimeout,
|
|
button_placeholder_id : settings.id,
|
|
button_width : settings.width,
|
|
button_height : settings.height,
|
|
button_text : null,
|
|
button_text_style : null,
|
|
button_text_top_padding : 0,
|
|
button_text_left_padding : 0,
|
|
button_action : (settings.multi ? SWFUpload.BUTTON_ACTION.SELECT_FILES
|
|
: SWFUpload.BUTTON_ACTION.SELECT_FILE),
|
|
button_disabled : false,
|
|
button_cursor : (settings.buttonCursor == 'arrow' ? SWFUpload.CURSOR.ARROW
|
|
: SWFUpload.CURSOR.HAND),
|
|
button_window_mode : SWFUpload.WINDOW_MODE.TRANSPARENT,
|
|
debug : settings.debug,
|
|
requeue_on_error : settings.requeueErrors,
|
|
file_post_name : settings.fileObjName,
|
|
file_size_limit : settings.fileSizeLimit,
|
|
file_types : settings.fileTypeExts,
|
|
file_types_description : settings.fileTypeDesc,
|
|
file_queue_limit : settings.queueSizeLimit,
|
|
file_upload_limit : settings.uploadLimit,
|
|
flash_url : settings.swf,
|
|
prevent_swf_caching : settings.preventCaching,
|
|
post_params : settings.formData,
|
|
upload_url : settings.uploader,
|
|
use_query_string : (settings.method == 'get'),
|
|
|
|
// Event Handlers
|
|
file_dialog_complete_handler : handlers.onDialogClose,
|
|
file_dialog_start_handler : handlers.onDialogOpen,
|
|
file_queued_handler : handlers.onSelect,
|
|
file_queue_error_handler : handlers.onSelectError,
|
|
swfupload_loaded_handler : settings.onSWFReady,
|
|
upload_complete_handler : handlers.onUploadComplete,
|
|
upload_error_handler : handlers.onUploadError,
|
|
upload_progress_handler : handlers.onUploadProgress,
|
|
upload_start_handler : handlers.onUploadStart,
|
|
upload_success_handler : handlers.onUploadSuccess
|
|
}
|
|
|
|
// Merge the user-defined options with the defaults
|
|
if (swfUploadOptions) {
|
|
swfUploadSettings = $.extend(swfUploadSettings,
|
|
swfUploadOptions);
|
|
}
|
|
// Add the user-defined settings to the swfupload object
|
|
swfUploadSettings = $.extend(swfUploadSettings,
|
|
settings);
|
|
|
|
// Detect if Flash is available
|
|
var playerVersion = swfobject.getFlashPlayerVersion();
|
|
var flashInstalled = (playerVersion.major >= 9);
|
|
|
|
if (flashInstalled) {
|
|
// Create the swfUpload instance
|
|
window['uploadify_' + settings.id] = new SWFUpload(
|
|
swfUploadSettings);
|
|
var swfuploadify = window['uploadify_'
|
|
+ settings.id];
|
|
|
|
// Add the SWFUpload object to the elements data
|
|
// object
|
|
$this.data('uploadify', swfuploadify);
|
|
|
|
// Wrap the instance
|
|
var $wrapper = $('<div />', {
|
|
'id' : settings.id,
|
|
'class' : 'uploadify',
|
|
'css' : {
|
|
'height' : settings.height + 'px',
|
|
'width' : settings.width + 'px'
|
|
}
|
|
});
|
|
$('#' + swfuploadify.movieName).wrap($wrapper);
|
|
// Recreate the reference to wrapper
|
|
$wrapper = $('#' + settings.id);
|
|
// Add the data object to the wrapper
|
|
$wrapper.data('uploadify', swfuploadify);
|
|
|
|
// Create the button
|
|
var $button = $('<div />', {
|
|
'id' : settings.id + '-button',
|
|
'class' : 'uploadify-button '
|
|
+ settings.buttonClass
|
|
});
|
|
if (settings.buttonImage) {
|
|
$button.css({
|
|
'background-image' : "url('"
|
|
+ settings.buttonImage + "')",
|
|
'text-indent' : '-9999px'
|
|
});
|
|
}
|
|
$button.html(
|
|
'<span class="uploadify-button-text">'
|
|
+ settings.buttonText + '</span>')
|
|
.css({
|
|
'height' : settings.height + 'px',
|
|
'line-height' : settings.height + 'px',
|
|
'width' : settings.width + 'px'
|
|
});
|
|
// Append the button to the wrapper
|
|
$wrapper.append($button);
|
|
|
|
// Adjust the styles of the movie
|
|
$('#' + swfuploadify.movieName).css({
|
|
'position' : 'absolute',
|
|
'z-index' : 1
|
|
});
|
|
|
|
// Create the file queue
|
|
if (!settings.queueID) {
|
|
var $queue = $('<div />', {
|
|
'id' : settings.id + '-queue',
|
|
'class' : 'uploadify-queue'
|
|
});
|
|
$wrapper.after($queue);
|
|
swfuploadify.settings.queueID = settings.id
|
|
+ '-queue';
|
|
swfuploadify.settings.defaultQueue = true;
|
|
}
|
|
|
|
// Create some queue related objects and variables
|
|
swfuploadify.queueData = {
|
|
files : {}, // The files in the queue
|
|
filesSelected : 0, // The number of files
|
|
// selected in the last
|
|
// select operation
|
|
filesQueued : 0, // The number of files added
|
|
// to the queue in the last
|
|
// select operation
|
|
filesReplaced : 0, // The number of files
|
|
// replaced in the last
|
|
// select operation
|
|
filesCancelled : 0, // The number of files that
|
|
// were cancelled instead of
|
|
// replaced
|
|
filesErrored : 0, // The number of files that
|
|
// caused error in the last
|
|
// select operation
|
|
uploadsSuccessful : 0, // The number of files
|
|
// that were
|
|
// successfully uploaded
|
|
uploadsErrored : 0, // The number of files that
|
|
// returned errors during
|
|
// upload
|
|
averageSpeed : 0, // The average speed of the
|
|
// uploads in KB
|
|
queueLength : 0, // The number of files in
|
|
// the queue
|
|
queueSize : 0, // The size in bytes of the
|
|
// entire queue
|
|
uploadSize : 0, // The size in bytes of the
|
|
// upload queue
|
|
queueBytesUploaded : 0, // The size in bytes
|
|
// that have been
|
|
// uploaded for the
|
|
// current upload queue
|
|
uploadQueue : [], // The files currently to be
|
|
// uploaded
|
|
errorMsg : 'Some files were not added to the queue:'
|
|
};
|
|
|
|
// Save references to all the objects
|
|
swfuploadify.original = $clone;
|
|
swfuploadify.wrapper = $wrapper;
|
|
swfuploadify.button = $button;
|
|
swfuploadify.queue = $queue;
|
|
|
|
// Call the user-defined init event handler
|
|
if (settings.onInit)
|
|
settings.onInit.call($this, swfuploadify);
|
|
|
|
} else {
|
|
|
|
// Call the fallback function
|
|
if (settings.onFallback)
|
|
settings.onFallback.call($this);
|
|
|
|
}
|
|
});
|
|
|
|
},
|
|
|
|
// Stop a file upload and remove it from the queue
|
|
cancel : function(fileID, supressEvent) {
|
|
|
|
var args = arguments;
|
|
|
|
this
|
|
.each(function() {
|
|
// Create a reference to the jQuery DOM object
|
|
var $this = $(this), swfuploadify = $this
|
|
.data('uploadify'), settings = swfuploadify.settings, delay = -1;
|
|
|
|
if (args[0]) {
|
|
// Clear the queue
|
|
if (args[0] == '*') {
|
|
var queueItemCount = swfuploadify.queueData.queueLength;
|
|
$('#' + settings.queueID).find(
|
|
'.uploadify-queue-item').each(
|
|
function() {
|
|
delay++;
|
|
if (args[1] === true) {
|
|
swfuploadify
|
|
.cancelUpload($(this)
|
|
.attr('id'),
|
|
false);
|
|
} else {
|
|
swfuploadify.cancelUpload($(
|
|
this).attr('id'));
|
|
}
|
|
$(this).find('.data').removeClass(
|
|
'data')
|
|
.html(' - 已取消');
|
|
$(this).find(
|
|
'.uploadify-progress-bar')
|
|
.remove();
|
|
$(this).delay(1000 + 100 * delay)
|
|
.fadeOut(500, function() {
|
|
$(this).remove();
|
|
});
|
|
});
|
|
swfuploadify.queueData.queueSize = 0;
|
|
swfuploadify.queueData.queueLength = 0;
|
|
// Trigger the onClearQueue event
|
|
if (settings.onClearQueue)
|
|
settings.onClearQueue.call($this,
|
|
queueItemCount);
|
|
} else {
|
|
for ( var n = 0; n < args.length; n++) {
|
|
swfuploadify.cancelUpload(args[n]);
|
|
$('#' + args[n]).find('.data').removeClass(
|
|
'data').html(' - 已取消');
|
|
$('#' + args[n]).find(
|
|
'.uploadify-progress-bar').remove();
|
|
$('#' + args[n]).delay(1000 + 100 * n)
|
|
.fadeOut(500, function() {
|
|
$(this).remove();
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
var item = $('#' + settings.queueID).find(
|
|
'.uploadify-queue-item').get(0);
|
|
$item = $(item);
|
|
swfuploadify.cancelUpload($item.attr('id'));
|
|
$item.find('.data').removeClass('data').html(
|
|
' - Cancelled');
|
|
$item.find('.uploadify-progress-bar').remove();
|
|
$item.delay(1000).fadeOut(500, function() {
|
|
$(this).remove();
|
|
});
|
|
}
|
|
});
|
|
|
|
},
|
|
|
|
// Revert the DOM object back to its original state
|
|
destroy : function() {
|
|
|
|
this
|
|
.each(function() {
|
|
// Create a reference to the jQuery DOM object
|
|
var $this = $(this), swfuploadify = $this
|
|
.data('uploadify'), settings = swfuploadify.settings;
|
|
|
|
// Destroy the SWF object and
|
|
swfuploadify.destroy();
|
|
|
|
// Destroy the queue
|
|
if (settings.defaultQueue) {
|
|
$('#' + settings.queueID).remove();
|
|
}
|
|
|
|
// Reload the original DOM element
|
|
$('#' + settings.id).replaceWith(swfuploadify.original);
|
|
|
|
// Call the user-defined event handler
|
|
if (settings.onDestroy)
|
|
settings.onDestroy.call(this);
|
|
|
|
delete swfuploadify;
|
|
});
|
|
|
|
},
|
|
|
|
// Disable the select button
|
|
disable : function(isDisabled) {
|
|
|
|
this
|
|
.each(function() {
|
|
// Create a reference to the $uery DOM object
|
|
var $this = $(this), swfuploadify = $this
|
|
.data('uploadify'), settings = swfuploadify.settings;
|
|
|
|
// Call the user-defined event handlers
|
|
if (isDisabled) {
|
|
swfuploadify.button.addClass('disabled');
|
|
if (settings.onDisable)
|
|
settings.onDisable.call(this);
|
|
} else {
|
|
swfuploadify.button.removeClass('disabled');
|
|
if (settings.onEnable)
|
|
settings.onEnable.call(this);
|
|
}
|
|
|
|
// Enable/disable the browse button
|
|
swfuploadify.setButtonDisabled(isDisabled);
|
|
});
|
|
|
|
},
|
|
|
|
// Get or set the settings data
|
|
settings : function(name, value, resetObjects) {
|
|
|
|
var args = arguments;
|
|
var returnValue = value;
|
|
|
|
this
|
|
.each(function() {
|
|
// Create a reference to the jQuery DOM object
|
|
var $this = $(this), swfuploadify = $this
|
|
.data('uploadify'), settings = swfuploadify.settings;
|
|
|
|
if (typeof (args[0]) == 'object') {
|
|
for ( var n in value) {
|
|
setData(n, value[n]);
|
|
}
|
|
}
|
|
if (args.length === 1) {
|
|
returnValue = settings[name];
|
|
} else {
|
|
switch (name) {
|
|
case 'uploader':
|
|
swfuploadify.setUploadURL(value);
|
|
break;
|
|
case 'formData':
|
|
if (!resetObjects) {
|
|
value = $.extend(settings.formData, value);
|
|
}
|
|
swfuploadify.setPostParams(settings.formData);
|
|
break;
|
|
case 'method':
|
|
if (value == 'get') {
|
|
swfuploadify.setUseQueryString(true);
|
|
} else {
|
|
swfuploadify.setUseQueryString(false);
|
|
}
|
|
break;
|
|
case 'fileObjName':
|
|
swfuploadify.setFilePostName(value);
|
|
break;
|
|
case 'fileTypeExts':
|
|
swfuploadify.setFileTypes(value,
|
|
settings.fileTypeDesc);
|
|
break;
|
|
case 'fileTypeDesc':
|
|
swfuploadify.setFileTypes(
|
|
settings.fileTypeExts, value);
|
|
break;
|
|
case 'fileSizeLimit':
|
|
swfuploadify.setFileSizeLimit(value);
|
|
break;
|
|
case 'uploadLimit':
|
|
swfuploadify.setFileUploadLimit(value);
|
|
break;
|
|
case 'queueSizeLimit':
|
|
swfuploadify.setFileQueueLimit(value);
|
|
break;
|
|
case 'buttonImage':
|
|
swfuploadify.button.css('background-image',
|
|
settingValue);
|
|
break;
|
|
case 'buttonCursor':
|
|
if (value == 'arrow') {
|
|
swfuploadify
|
|
.setButtonCursor(SWFUpload.CURSOR.ARROW);
|
|
} else {
|
|
swfuploadify
|
|
.setButtonCursor(SWFUpload.CURSOR.HAND);
|
|
}
|
|
break;
|
|
case 'buttonText':
|
|
$('#' + settings.id + '-button').find(
|
|
'.uploadify-button-text').html(value);
|
|
break;
|
|
case 'width':
|
|
swfuploadify.setButtonDimensions(value,
|
|
settings.height);
|
|
break;
|
|
case 'height':
|
|
swfuploadify.setButtonDimensions(
|
|
settings.width, value);
|
|
break;
|
|
case 'multi':
|
|
if (value) {
|
|
swfuploadify
|
|
.setButtonAction(SWFUpload.BUTTON_ACTION.SELECT_FILES);
|
|
} else {
|
|
swfuploadify
|
|
.setButtonAction(SWFUpload.BUTTON_ACTION.SELECT_FILE);
|
|
}
|
|
break;
|
|
}
|
|
settings[name] = value;
|
|
}
|
|
});
|
|
|
|
if (args.length === 1) {
|
|
return returnValue;
|
|
}
|
|
|
|
},
|
|
|
|
// Stop the current uploads and requeue what is in progress
|
|
stop : function() {
|
|
|
|
this.each(function() {
|
|
// Create a reference to the jQuery DOM object
|
|
var $this = $(this), swfuploadify = $this.data('uploadify');
|
|
|
|
// Reset the queue information
|
|
swfuploadify.queueData.averageSpeed = 0;
|
|
swfuploadify.queueData.uploadSize = 0;
|
|
swfuploadify.queueData.bytesUploaded = 0;
|
|
swfuploadify.queueData.uploadQueue = [];
|
|
|
|
swfuploadify.stopUpload();
|
|
});
|
|
|
|
},
|
|
|
|
// Start uploading files in the queue
|
|
upload : function() {
|
|
|
|
var args = arguments;
|
|
|
|
this
|
|
.each(function() {
|
|
// Create a reference to the jQuery DOM object
|
|
var $this = $(this), swfuploadify = $this
|
|
.data('uploadify');
|
|
|
|
// Reset the queue information
|
|
swfuploadify.queueData.averageSpeed = 0;
|
|
swfuploadify.queueData.uploadSize = 0;
|
|
swfuploadify.queueData.bytesUploaded = 0;
|
|
swfuploadify.queueData.uploadQueue = [];
|
|
|
|
// Upload the files
|
|
if (args[0]) {
|
|
if (args[0] == '*') {
|
|
swfuploadify.queueData.uploadSize = swfuploadify.queueData.queueSize;
|
|
swfuploadify.queueData.uploadQueue.push('*');
|
|
swfuploadify.startUpload();
|
|
} else {
|
|
for ( var n = 0; n < args.length; n++) {
|
|
swfuploadify.queueData.uploadSize += swfuploadify.queueData.files[args[n]].size;
|
|
swfuploadify.queueData.uploadQueue
|
|
.push(args[n]);
|
|
}
|
|
swfuploadify
|
|
.startUpload(swfuploadify.queueData.uploadQueue
|
|
.shift());
|
|
}
|
|
} else {
|
|
swfuploadify.startUpload();
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// These functions handle all the events that occur with the file uploader
|
|
var handlers = {
|
|
|
|
// Triggered when the file dialog is opened
|
|
onDialogOpen : function() {
|
|
// Load the swfupload settings
|
|
var settings = this.settings;
|
|
|
|
// Reset some queue info
|
|
this.queueData.errorMsg = 'Some files were not added to the queue:';
|
|
this.queueData.filesReplaced = 0;
|
|
this.queueData.filesCancelled = 0;
|
|
|
|
// Call the user-defined event handler
|
|
if (settings.onDialogOpen)
|
|
settings.onDialogOpen.call(this);
|
|
},
|
|
|
|
// Triggered when the browse dialog is closed
|
|
onDialogClose : function(filesSelected, filesQueued, queueLength) {
|
|
// Load the swfupload settings
|
|
var settings = this.settings;
|
|
|
|
// Update the queue information
|
|
this.queueData.filesErrored = filesSelected - filesQueued;
|
|
this.queueData.filesSelected = filesSelected;
|
|
this.queueData.filesQueued = filesQueued
|
|
- this.queueData.filesCancelled;
|
|
this.queueData.queueLength = queueLength;
|
|
|
|
// Run the default event handler
|
|
if ($.inArray('onDialogClose', settings.overrideEvents) < 0) {
|
|
if (this.queueData.filesErrored > 0) {
|
|
alert(this.queueData.errorMsg);
|
|
}
|
|
}
|
|
|
|
// Call the user-defined event handler
|
|
if (settings.onDialogClose)
|
|
settings.onDialogClose.call(this, this.queueData);
|
|
|
|
// Upload the files if auto is true
|
|
if (settings.auto)
|
|
$('#' + settings.id).uploadify('upload', '*');
|
|
},
|
|
|
|
// Triggered once for each file added to the queue
|
|
onSelect : function(file) {
|
|
// Load the swfupload settings
|
|
var settings = this.settings;
|
|
|
|
// Check if a file with the same name exists in the queue
|
|
var queuedFile = {};
|
|
for ( var n in this.queueData.files) {
|
|
queuedFile = this.queueData.files[n];
|
|
if (queuedFile.uploaded != true && queuedFile.name == file.name) {
|
|
var replaceQueueItem = confirm('The file named "'
|
|
+ file.name
|
|
+ '" is already in the queue.\nDo you want to replace the existing item in the queue?');
|
|
if (!replaceQueueItem) {
|
|
this.cancelUpload(file.id);
|
|
this.queueData.filesCancelled++;
|
|
return false;
|
|
} else {
|
|
$('#' + queuedFile.id).remove();
|
|
this.cancelUpload(queuedFile.id);
|
|
this.queueData.filesReplaced++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get the size of the file
|
|
var fileSize = Math.round(file.size / 1024);
|
|
var suffix = 'KB';
|
|
if (fileSize > 1000) {
|
|
fileSize = Math.round(fileSize / 1000);
|
|
suffix = 'MB';
|
|
}
|
|
var fileSizeParts = fileSize.toString().split('.');
|
|
fileSize = fileSizeParts[0];
|
|
if (fileSizeParts.length > 1) {
|
|
fileSize += '.' + fileSizeParts[1].substr(0, 2);
|
|
}
|
|
fileSize += suffix;
|
|
|
|
// Truncate the filename if it's too long
|
|
var fileName = file.name;
|
|
if (fileName.length > 25) {
|
|
fileName = fileName.substr(0, 25) + '...';
|
|
}
|
|
|
|
// Run the default event handler
|
|
if ($.inArray('onSelect', settings.overrideEvents) < 0) {
|
|
|
|
// Add the file item to the queue
|
|
$('#' + settings.queueID)
|
|
.append(
|
|
'<div id="'
|
|
+ file.id
|
|
+ '" class="uploadify-queue-item">\
|
|
<div class="cancel">\
|
|
<a href="javascript:$(\'#'
|
|
+ settings.id
|
|
+ '\').uploadify(\'cancel\', \''
|
|
+ file.id
|
|
+ '\')">X</a>\
|
|
</div>\
|
|
<span class="fileName">'
|
|
+ fileName
|
|
+ ' ('
|
|
+ fileSize
|
|
+ ')</span><span class="data"></span>\
|
|
<div class="uploadify-progress">\
|
|
<div class="uploadify-progress-bar"><!--Progress Bar--></div>\
|
|
</div>\
|
|
</div>');
|
|
|
|
}
|
|
|
|
this.queueData.queueSize += file.size;
|
|
this.queueData.files[file.id] = file;
|
|
|
|
// Call the user-defined event handler
|
|
if (settings.onSelect)
|
|
settings.onSelect.apply(this, arguments);
|
|
},
|
|
|
|
// Triggered when a file is not added to the queue
|
|
onSelectError : function(file, errorCode, errorMsg) {
|
|
// Load the swfupload settings
|
|
var settings = this.settings;
|
|
|
|
// Run the default event handler
|
|
if ($.inArray('onSelectError', settings.overrideEvents) < 0) {
|
|
switch (errorCode) {
|
|
case SWFUpload.QUEUE_ERROR.QUEUE_LIMIT_EXCEEDED:
|
|
if (settings.queueSizeLimit > errorMsg) {
|
|
this.queueData.errorMsg += '\nThe number of files selected exceeds the remaining upload limit ('
|
|
+ errorMsg + ').';
|
|
} else {
|
|
this.queueData.errorMsg += '\nThe number of files selected exceeds the queue size limit ('
|
|
+ settings.queueSizeLimit + ').';
|
|
}
|
|
break;
|
|
case SWFUpload.QUEUE_ERROR.FILE_EXCEEDS_SIZE_LIMIT:
|
|
this.queueData.errorMsg += '\nThe file "' + file.name
|
|
+ '" exceeds the size limit ('
|
|
+ settings.fileSizeLimit + ').';
|
|
break;
|
|
case SWFUpload.QUEUE_ERROR.ZERO_BYTE_FILE:
|
|
this.queueData.errorMsg += '\nThe file "' + file.name
|
|
+ '" is empty.';
|
|
break;
|
|
case SWFUpload.QUEUE_ERROR.FILE_EXCEEDS_SIZE_LIMIT:
|
|
this.queueData.errorMsg += '\nThe file "' + file.name
|
|
+ '" is not an accepted file type ('
|
|
+ settings.fileTypeDesc + ').';
|
|
break;
|
|
}
|
|
}
|
|
if (errorCode != SWFUpload.QUEUE_ERROR.QUEUE_LIMIT_EXCEEDED) {
|
|
delete this.queueData.files[file.id];
|
|
}
|
|
|
|
// Call the user-defined event handler
|
|
if (settings.onSelectError)
|
|
settings.onSelectError.apply(this, arguments);
|
|
},
|
|
|
|
// Triggered when all the files in the queue have been processed
|
|
onQueueComplete : function() {
|
|
if (this.settings.onQueueComplete)
|
|
this.settings.onQueueComplete.call(this,
|
|
this.settings.queueData);
|
|
},
|
|
|
|
// Triggered when a file upload successfully completes
|
|
onUploadComplete : function(file) {
|
|
// Load the swfupload settings
|
|
var settings = this.settings, swfuploadify = this;
|
|
|
|
// Check if all the files have completed uploading
|
|
var stats = this.getStats();
|
|
this.queueData.queueLength = stats.files_queued;
|
|
if (this.queueData.uploadQueue[0] == '*') {
|
|
if (this.queueData.queueLength > 0) {
|
|
this.startUpload();
|
|
} else {
|
|
this.queueData.uploadQueue = [];
|
|
|
|
// Call the user-defined event handler for queue complete
|
|
if (settings.onQueueComplete)
|
|
settings.onQueueComplete.call(this, this.queueData);
|
|
}
|
|
} else {
|
|
if (this.queueData.uploadQueue.length > 0) {
|
|
this.startUpload(this.queueData.uploadQueue.shift());
|
|
} else {
|
|
this.queueData.uploadQueue = [];
|
|
|
|
// Call the user-defined event handler for queue complete
|
|
if (settings.onQueueComplete)
|
|
settings.onQueueComplete.call(this, this.queueData);
|
|
}
|
|
}
|
|
|
|
// Call the default event handler
|
|
if ($.inArray('onUploadComplete', settings.overrideEvents) < 0) {
|
|
if (settings.removeCompleted) {
|
|
switch (file.filestatus) {
|
|
case SWFUpload.FILE_STATUS.COMPLETE:
|
|
setTimeout(function() {
|
|
if ($('#' + file.id)) {
|
|
swfuploadify.queueData.queueSize -= file.size;
|
|
swfuploadify.queueData.queueLength -= 1;
|
|
delete swfuploadify.queueData.files[file.id]
|
|
$('#' + file.id).fadeOut(500, function() {
|
|
$(this).remove();
|
|
});
|
|
}
|
|
}, settings.removeTimeout * 1000);
|
|
break;
|
|
case SWFUpload.FILE_STATUS.ERROR:
|
|
if (!settings.requeueErrors) {
|
|
setTimeout(
|
|
function() {
|
|
if ($('#' + file.id)) {
|
|
swfuploadify.queueData.queueSize -= file.size;
|
|
swfuploadify.queueData.queueLength -= 1;
|
|
delete swfuploadify.queueData.files[file.id];
|
|
$('#' + file.id).fadeOut(500,
|
|
function() {
|
|
$(this).remove();
|
|
});
|
|
}
|
|
}, settings.removeTimeout * 1000);
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
file.uploaded = true;
|
|
}
|
|
}
|
|
|
|
// Call the user-defined event handler
|
|
if (settings.onUploadComplete)
|
|
settings.onUploadComplete.call(this, file);
|
|
},
|
|
|
|
// Triggered when a file upload returns an error
|
|
onUploadError : function(file, errorCode, errorMsg) {
|
|
// Load the swfupload settings
|
|
var settings = this.settings;
|
|
|
|
// Set the error string
|
|
var errorString = 'Error';
|
|
switch (errorCode) {
|
|
case SWFUpload.UPLOAD_ERROR.HTTP_ERROR:
|
|
errorString = 'HTTP Error (' + errorMsg + ')';
|
|
break;
|
|
case SWFUpload.UPLOAD_ERROR.MISSING_UPLOAD_URL:
|
|
errorString = 'Missing Upload URL';
|
|
break;
|
|
case SWFUpload.UPLOAD_ERROR.IO_ERROR:
|
|
errorString = 'IO Error';
|
|
break;
|
|
case SWFUpload.UPLOAD_ERROR.SECURITY_ERROR:
|
|
errorString = 'Security Error';
|
|
break;
|
|
case SWFUpload.UPLOAD_ERROR.UPLOAD_LIMIT_EXCEEDED:
|
|
alert('The upload limit has been reached (' + errorMsg + ').');
|
|
errorString = 'Exceeds Upload Limit';
|
|
break;
|
|
case SWFUpload.UPLOAD_ERROR.UPLOAD_FAILED:
|
|
errorString = 'Failed';
|
|
break;
|
|
case SWFUpload.UPLOAD_ERROR.SPECIFIED_FILE_ID_NOT_FOUND:
|
|
break;
|
|
case SWFUpload.UPLOAD_ERROR.FILE_VALIDATION_FAILED:
|
|
errorString = 'Validation Error';
|
|
break;
|
|
case SWFUpload.UPLOAD_ERROR.FILE_CANCELLED:
|
|
errorString = 'Cancelled';
|
|
this.queueData.queueSize -= file.size;
|
|
this.queueData.queueLength -= 1;
|
|
if (file.status == SWFUpload.FILE_STATUS.IN_PROGRESS
|
|
|| $.inArray(file.id, this.queueData.uploadQueue) >= 0) {
|
|
this.queueData.uploadSize -= file.size;
|
|
}
|
|
// Trigger the onCancel event
|
|
if (settings.onCancel)
|
|
settings.onCancel.call(this, file);
|
|
delete this.queueData.files[file.id];
|
|
break;
|
|
case SWFUpload.UPLOAD_ERROR.UPLOAD_STOPPED:
|
|
errorString = 'Stopped';
|
|
break;
|
|
}
|
|
|
|
// Call the default event handler
|
|
if ($.inArray('onUploadError', settings.overrideEvents) < 0) {
|
|
|
|
if (errorCode != SWFUpload.UPLOAD_ERROR.FILE_CANCELLED
|
|
&& errorCode != SWFUpload.UPLOAD_ERROR.UPLOAD_STOPPED) {
|
|
$('#' + file.id).addClass('uploadify-error');
|
|
}
|
|
|
|
// Reset the progress bar
|
|
$('#' + file.id).find('.uploadify-progress-bar').css('width',
|
|
'1px');
|
|
|
|
// Add the error message to the queue item
|
|
if (errorCode != SWFUpload.UPLOAD_ERROR.SPECIFIED_FILE_ID_NOT_FOUND
|
|
&& file.status != SWFUpload.FILE_STATUS.COMPLETE) {
|
|
$('#' + file.id).find('.data').html(' - ' + errorString);
|
|
}
|
|
}
|
|
|
|
var stats = this.getStats();
|
|
this.queueData.uploadsErrored = stats.upload_errors;
|
|
|
|
// Call the user-defined event handler
|
|
if (settings.onUploadError)
|
|
settings.onUploadError.call(this, file, errorCode, errorMsg,
|
|
errorString);
|
|
},
|
|
|
|
// Triggered periodically during a file upload
|
|
onUploadProgress : function(file, fileBytesLoaded, fileTotalBytes) {
|
|
// Load the swfupload settings
|
|
var settings = this.settings;
|
|
|
|
// Setup all the variables
|
|
var timer = new Date();
|
|
var newTime = timer.getTime();
|
|
var lapsedTime = newTime - this.timer;
|
|
if (lapsedTime > 500) {
|
|
this.timer = newTime;
|
|
}
|
|
var lapsedBytes = fileBytesLoaded - this.bytesLoaded;
|
|
this.bytesLoaded = fileBytesLoaded;
|
|
var queueBytesLoaded = this.queueData.queueBytesUploaded
|
|
+ fileBytesLoaded;
|
|
var percentage = Math.round(fileBytesLoaded / fileTotalBytes * 100);
|
|
|
|
// Calculate the average speed
|
|
var suffix = 'KB/s';
|
|
var mbs = 0;
|
|
var kbs = (lapsedBytes / 1024) / (lapsedTime / 1000);
|
|
kbs = Math.floor(kbs * 10) / 10;
|
|
if (this.queueData.averageSpeed > 0) {
|
|
this.queueData.averageSpeed = Math
|
|
.floor((this.queueData.averageSpeed + kbs) / 2);
|
|
} else {
|
|
this.queueData.averageSpeed = Math.floor(kbs);
|
|
}
|
|
if (kbs > 1000) {
|
|
mbs = (kbs * .001);
|
|
this.queueData.averageSpeed = Math.floor(mbs);
|
|
suffix = 'MB/s';
|
|
}
|
|
|
|
// Call the default event handler
|
|
if ($.inArray('onUploadProgress', settings.overrideEvents) < 0) {
|
|
if (settings.progressData == 'percentage') {
|
|
$('#' + file.id).find('.data').html(
|
|
' - ' + percentage + '%');
|
|
} else if (settings.progressData == 'speed' && lapsedTime > 500) {
|
|
$('#' + file.id).find('.data').html(
|
|
' - ' + this.queueData.averageSpeed + suffix);
|
|
}
|
|
$('#' + file.id).find('.uploadify-progress-bar').css('width',
|
|
percentage + '%');
|
|
}
|
|
|
|
// Call the user-defined event handler
|
|
if (settings.onUploadProgress)
|
|
settings.onUploadProgress.call(this, file, fileBytesLoaded,
|
|
fileTotalBytes, queueBytesLoaded,
|
|
this.queueData.uploadSize);
|
|
},
|
|
|
|
// Triggered right before a file is uploaded
|
|
onUploadStart : function(file) {
|
|
// Load the swfupload settings
|
|
var settings = this.settings;
|
|
|
|
var timer = new Date();
|
|
this.timer = timer.getTime();
|
|
this.bytesLoaded = 0;
|
|
if (this.queueData.uploadQueue.length == 0) {
|
|
this.queueData.uploadSize = file.size;
|
|
}
|
|
if (settings.checkExisting) {
|
|
$
|
|
.ajax({
|
|
type : 'POST',
|
|
async : false,
|
|
url : settings.checkExisting,
|
|
data : {
|
|
filename : file.name
|
|
},
|
|
success : function(data) {
|
|
if (data == 1) {
|
|
var overwrite = confirm('A file with the name "'
|
|
+ file.name
|
|
+ '" already exists on the server.\nWould you like to replace the existing file?');
|
|
if (!overwrite) {
|
|
this.cancelUpload(file.id);
|
|
$('#' + file.id).remove();
|
|
if (this.queueData.uploadQueue.length > 0
|
|
&& this.queueData.queueLength > 0) {
|
|
if (this.queueData.uploadQueue[0] == '*') {
|
|
this.startUpload();
|
|
} else {
|
|
this
|
|
.startUpload(this.queueData.uploadQueue
|
|
.shift());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// Call the user-defined event handler
|
|
if (settings.onUploadStart)
|
|
settings.onUploadStart.call(this, file);
|
|
},
|
|
|
|
// Triggered when a file upload returns a successful code
|
|
onUploadSuccess : function(file, data, response) {
|
|
// Load the swfupload settings
|
|
var settings = this.settings;
|
|
var stats = this.getStats();
|
|
this.queueData.uploadsSuccessful = stats.successful_uploads;
|
|
this.queueData.queueBytesUploaded += file.size;
|
|
|
|
// Call the default event handler
|
|
if ($.inArray('onUploadSuccess', settings.overrideEvents) < 0) {
|
|
$('#' + file.id).find('.data').html(' - Complete');
|
|
}
|
|
|
|
// Call the user-defined event handler
|
|
if (settings.onUploadSuccess)
|
|
settings.onUploadSuccess.call(this, file, data, response);
|
|
}
|
|
|
|
}
|
|
|
|
$.fn.uploadify = function(method) {
|
|
|
|
if (methods[method]) {
|
|
return methods[method].apply(this, Array.prototype.slice.call(
|
|
arguments, 1));
|
|
} else if (typeof method === 'object' || !method) {
|
|
return methods.init.apply(this, arguments);
|
|
} else {
|
|
$.error('The method ' + method + ' does not exist in $.uploadify');
|
|
}
|
|
|
|
}
|
|
|
|
})($); |