Created
February 11, 2013 15:13
-
-
Save dpnishant/4755012 to your computer and use it in GitHub Desktop.
This file contains 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
| if (typeof YAHOO == "undefined" || !YAHOO) { | |
| var YAHOO = {} | |
| } | |
| YAHOO.namespace = function () { | |
| var A = arguments, | |
| E = null, | |
| C, B, D; | |
| for (C = 0; C < A.length; C = C + 1) { | |
| D = ("" + A[C]) | |
| .split("."); | |
| E = YAHOO; | |
| for (B = (D[0] == "YAHOO") ? 1 : 0; B < D.length; B = B + 1) { | |
| E[D[B]] = E[D[B]] || {}; | |
| E = E[D[B]] | |
| } | |
| } | |
| return E | |
| }; | |
| YAHOO.log = function (D, A, C) { | |
| var B = YAHOO.widget.Logger; | |
| if (B && B.log) { | |
| return B.log(D, A, C) | |
| } else { | |
| return false | |
| } | |
| }; | |
| YAHOO.register = function (A, E, D) { | |
| var I = YAHOO.env.modules, | |
| B, H, G, F, C; | |
| if (!I[A]) { | |
| I[A] = { | |
| versions: [], | |
| builds: [] | |
| } | |
| } | |
| B = I[A]; | |
| H = D.version; | |
| G = D.build; | |
| F = YAHOO.env.listeners; | |
| B.name = A; | |
| B.version = H; | |
| B.build = G; | |
| B.versions.push(H); | |
| B.builds.push(G); | |
| B.mainClass = E; | |
| for (C = 0; C < F.length; C = C + 1) { | |
| F[C](B) | |
| } | |
| if (E) { | |
| E.VERSION = H; | |
| E.BUILD = G | |
| } else { | |
| YAHOO.log("mainClass is undefined for module " + A, "warn") | |
| } | |
| }; | |
| YAHOO.env = YAHOO.env || { | |
| modules: [], | |
| listeners: [] | |
| }; | |
| YAHOO.env.getVersion = function (A) { | |
| return YAHOO.env.modules[A] || null | |
| }; | |
| YAHOO.env.ua = function () { | |
| var C = { | |
| ie: 0, | |
| opera: 0, | |
| gecko: 0, | |
| webkit: 0, | |
| mobile: null, | |
| air: 0, | |
| caja: 0 | |
| }, B = navigator.userAgent, | |
| A; | |
| if ((/KHTML/) | |
| .test(B)) { | |
| C.webkit = 1 | |
| } | |
| A = B.match(/AppleWebKit\/([^\s]*)/); | |
| if (A && A[1]) { | |
| C.webkit = parseFloat(A[1]); | |
| if (/ Mobile\//.test(B)) { | |
| C.mobile = "Apple" | |
| } else { | |
| A = B.match(/NokiaN[^\/]*/); | |
| if (A) { | |
| C.mobile = A[0] | |
| } | |
| } | |
| A = B.match(/AdobeAIR\/([^\s]*)/); | |
| if (A) { | |
| C.air = A[0] | |
| } | |
| } | |
| if (!C.webkit) { | |
| A = B.match(/Opera[\s\/]([^\s]*)/); | |
| if (A && A[1]) { | |
| C.opera = parseFloat(A[1]); | |
| A = B.match(/Opera Mini[^;]*/); | |
| if (A) { | |
| C.mobile = A[0] | |
| } | |
| } else { | |
| A = B.match(/MSIE\s([^;]*)/); | |
| if (A && A[1]) { | |
| C.ie = parseFloat(A[1]) | |
| } else { | |
| A = B.match(/Gecko\/([^\s]*)/); | |
| if (A) { | |
| C.gecko = 1; | |
| A = B.match(/rv:([^\s\)]*)/); | |
| if (A && A[1]) { | |
| C.gecko = parseFloat(A[1]) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| A = B.match(/Caja\/([^\s]*)/); | |
| if (A && A[1]) { | |
| C.caja = parseFloat(A[1]) | |
| } | |
| return C | |
| }(); | |
| (function () { | |
| YAHOO.namespace("util", "widget", "example"); | |
| if ("undefined" !== typeof YAHOO_config) { | |
| var B = YAHOO_config.listener, | |
| A = YAHOO.env.listeners, | |
| D = true, | |
| C; | |
| if (B) { | |
| for (C = 0; C < A.length; C = C + 1) { | |
| if (A[C] == B) { | |
| D = false; | |
| break | |
| } | |
| } | |
| if (D) { | |
| A.push(B) | |
| } | |
| } | |
| } | |
| })(); | |
| YAHOO.lang = YAHOO.lang || {}; | |
| (function () { | |
| var B = YAHOO.lang, | |
| F = "[object Array]", | |
| C = "[object Function]", | |
| A = Object.prototype, | |
| E = ["toString", "valueOf"], | |
| D = { | |
| isArray: function (G) { | |
| return A.toString.apply(G) === F | |
| }, | |
| isBoolean: function (G) { | |
| return typeof G === "boolean" | |
| }, | |
| isFunction: function (G) { | |
| return A.toString.apply(G) === C | |
| }, | |
| isNull: function (G) { | |
| return G === null | |
| }, | |
| isNumber: function (G) { | |
| return typeof G === "number" && isFinite(G) | |
| }, | |
| isObject: function (G) { | |
| return (G && (typeof G === "object" || B.isFunction(G))) || false | |
| }, | |
| isString: function (G) { | |
| return typeof G === "string" | |
| }, | |
| isUndefined: function (G) { | |
| return typeof G === "undefined" | |
| }, | |
| _IEEnumFix: (YAHOO.env.ua.ie) ? function (I, H) { | |
| var G, K, J; | |
| for (G = 0; G < E.length; G = G + 1) { | |
| K = E[G]; | |
| J = H[K]; | |
| if (B.isFunction(J) && J != A[K]) { | |
| I[K] = J | |
| } | |
| } | |
| } : function () {}, | |
| extend: function (J, K, I) { | |
| if (!K || !J) { | |
| throw new Error("extend failed, please check that all dependencies are included.") | |
| } | |
| var H = function () {}, G; | |
| H.prototype = K.prototype; | |
| J.prototype = new H(); | |
| J.prototype.constructor = J; | |
| J.superclass = K.prototype; | |
| if (K.prototype.constructor == A.constructor) { | |
| K.prototype.constructor = K | |
| } | |
| if (I) { | |
| for (G in I) { | |
| if (B.hasOwnProperty(I, G)) { | |
| J.prototype[G] = I[G] | |
| } | |
| } | |
| B._IEEnumFix(J.prototype, I) | |
| } | |
| }, | |
| augmentObject: function (K, J) { | |
| if (!J || !K) { | |
| throw new Error("Absorb failed, verify dependencies.") | |
| } | |
| var G = arguments, | |
| I, L, H = G[2]; | |
| if (H && H !== true) { | |
| for (I = 2; I < G.length; I = I + 1) { | |
| K[G[I]] = J[G[I]] | |
| } | |
| } else { | |
| for (L in J) { | |
| if (H || !(L in K)) { | |
| K[L] = J[L] | |
| } | |
| } | |
| B._IEEnumFix(K, J) | |
| } | |
| }, | |
| augmentProto: function (J, I) { | |
| if (!I || !J) { | |
| throw new Error("Augment failed, verify dependencies.") | |
| } | |
| var G = [J.prototype, I.prototype], | |
| H; | |
| for (H = 2; H < arguments.length; H = H + 1) { | |
| G.push(arguments[H]) | |
| } | |
| B.augmentObject.apply(this, G) | |
| }, | |
| dump: function (G, L) { | |
| var I, K, N = [], | |
| O = "{...}", | |
| H = "f(){...}", | |
| M = ", ", | |
| J = " => "; | |
| if (!B.isObject(G)) { | |
| return G + "" | |
| } else { | |
| if (G instanceof Date || ("nodeType" in G && "tagName" in G)) { | |
| return G | |
| } else { | |
| if (B.isFunction(G)) { | |
| return H | |
| } | |
| } | |
| } | |
| L = (B.isNumber(L)) ? L : 3; | |
| if (B.isArray(G)) { | |
| N.push("["); | |
| for (I = 0, K = G.length; I < K; I = I + 1) { | |
| if (B.isObject(G[I])) { | |
| N.push((L > 0) ? B.dump(G[I], L - 1) : O) | |
| } else { | |
| N.push(G[I]) | |
| } | |
| N.push(M) | |
| } | |
| if (N.length > 1) { | |
| N.pop() | |
| } | |
| N.push("]") | |
| } else { | |
| N.push("{"); | |
| for (I in G) { | |
| if (B.hasOwnProperty(G, I)) { | |
| N.push(I + J); | |
| if (B.isObject(G[I])) { | |
| N.push((L > 0) ? B.dump(G[I], L - 1) : O) | |
| } else { | |
| N.push(G[I]) | |
| } | |
| N.push(M) | |
| } | |
| } | |
| if (N.length > 1) { | |
| N.pop() | |
| } | |
| N.push("}") | |
| } | |
| return N.join("") | |
| }, | |
| substitute: function (V, H, O) { | |
| var L, K, J, R, S, U, Q = [], | |
| I, M = "dump", | |
| P = " ", | |
| G = "{", | |
| T = "}", | |
| N; | |
| for (;;) { | |
| L = V.lastIndexOf(G); | |
| if (L < 0) { | |
| break | |
| } | |
| K = V.indexOf(T, L); | |
| if (L + 1 >= K) { | |
| break | |
| } | |
| I = V.substring(L + 1, K); | |
| R = I; | |
| U = null; | |
| J = R.indexOf(P); | |
| if (J > -1) { | |
| U = R.substring(J + 1); | |
| R = R.substring(0, J) | |
| } | |
| S = H[R]; | |
| if (O) { | |
| S = O(R, S, U) | |
| } | |
| if (B.isObject(S)) { | |
| if (B.isArray(S)) { | |
| S = B.dump(S, parseInt(U, 10)) | |
| } else { | |
| U = U || ""; | |
| N = U.indexOf(M); | |
| if (N > -1) { | |
| U = U.substring(4) | |
| } | |
| if (S.toString === A.toString || N > -1) { | |
| S = B.dump(S, parseInt(U, 10)) | |
| } else { | |
| S = S.toString() | |
| } | |
| } | |
| } else { | |
| if (!B.isString(S) && !B.isNumber(S)) { | |
| S = "~-" + Q.length + "-~"; | |
| Q[Q.length] = I | |
| } | |
| } | |
| V = V.substring(0, L) + S + V.substring(K + 1) | |
| } | |
| for (L = Q.length - 1; L >= 0; L = L - 1) { | |
| V = V.replace(new RegExp("~-" + L + "-~"), "{" + Q[L] + "}", "g") | |
| } | |
| return V | |
| }, | |
| trim: function (G) { | |
| try { | |
| return G.replace(/^\s+|\s+$/g, "") | |
| } catch (H) { | |
| return G | |
| } | |
| }, | |
| merge: function () { | |
| var J = {}, H = arguments, | |
| G = H.length, | |
| I; | |
| for (I = 0; I < G; I = I + 1) { | |
| B.augmentObject(J, H[I], true) | |
| } | |
| return J | |
| }, | |
| later: function (N, H, O, J, K) { | |
| N = N || 0; | |
| H = H || {}; | |
| var I = O, | |
| M = J, | |
| L, G; | |
| if (B.isString(O)) { | |
| I = H[O] | |
| } | |
| if (!I) { | |
| throw new TypeError("method undefined") | |
| } | |
| if (!B.isArray(M)) { | |
| M = [J] | |
| } | |
| L = function () { | |
| I.apply(H, M) | |
| }; | |
| G = (K) ? setInterval(L, N) : setTimeout(L, N); | |
| return { | |
| interval: K, | |
| cancel: function () { | |
| if (this.interval) { | |
| clearInterval(G) | |
| } else { | |
| clearTimeout(G) | |
| } | |
| } | |
| } | |
| }, | |
| isValue: function (G) { | |
| return (B.isObject(G) || B.isString(G) || B.isNumber(G) || B.isBoolean(G)) | |
| } | |
| }; | |
| B.hasOwnProperty = (A.hasOwnProperty) ? function (G, H) { | |
| return G && G.hasOwnProperty(H) | |
| } : function (G, H) { | |
| return !B.isUndefined(G[H]) && G.constructor.prototype[H] !== G[H] | |
| }; | |
| D.augmentObject(B, D, true); | |
| YAHOO.util.Lang = B; | |
| B.augment = B.augmentProto; | |
| YAHOO.augment = B.augmentProto; | |
| YAHOO.extend = B.extend | |
| })(); | |
| YAHOO.register("yahoo", YAHOO, { | |
| version: "2.7.0", | |
| build: "1796" | |
| }); | |
| YAHOO.util.CustomEvent = function (D, C, B, A) { | |
| this.type = D; | |
| this.scope = C || window; | |
| this.silent = B; | |
| this.signature = A || YAHOO.util.CustomEvent.LIST; | |
| this.subscribers = []; | |
| if (!this.silent) {} | |
| var E = "_YUICEOnSubscribe"; | |
| if (D !== E) { | |
| this.subscribeEvent = new YAHOO.util.CustomEvent(E, this, true) | |
| } | |
| this.lastError = null | |
| }; | |
| YAHOO.util.CustomEvent.LIST = 0; | |
| YAHOO.util.CustomEvent.FLAT = 1; | |
| YAHOO.util.CustomEvent.prototype = { | |
| subscribe: function (A, B, C) { | |
| if (!A) { | |
| throw new Error("Invalid callback for subscriber to '" + this.type + "'") | |
| } | |
| if (this.subscribeEvent) { | |
| this.subscribeEvent.fire(A, B, C) | |
| } | |
| this.subscribers.push(new YAHOO.util.Subscriber(A, B, C)) | |
| }, | |
| unsubscribe: function (D, F) { | |
| if (!D) { | |
| return this.unsubscribeAll() | |
| } | |
| var E = false; | |
| for (var B = 0, A = this.subscribers.length; B < A; ++B) { | |
| var C = this.subscribers[B]; | |
| if (C && C.contains(D, F)) { | |
| this._delete(B); | |
| E = true | |
| } | |
| } | |
| return E | |
| }, | |
| fire: function () { | |
| this.lastError = null; | |
| var K = [], | |
| E = this.subscribers.length; | |
| if (!E && this.silent) { | |
| return true | |
| } | |
| var I = [].slice.call(arguments, 0), | |
| G = true, | |
| D, J = false; | |
| if (!this.silent) {} | |
| var C = this.subscribers.slice(), | |
| A = YAHOO.util.Event.throwErrors; | |
| for (D = 0; D < E; ++D) { | |
| var M = C[D]; | |
| if (!M) { | |
| J = true | |
| } else { | |
| if (!this.silent) {} | |
| var L = M.getScope(this.scope); | |
| if (this.signature == YAHOO.util.CustomEvent.FLAT) { | |
| var B = null; | |
| if (I.length > 0) { | |
| B = I[0] | |
| } | |
| try { | |
| G = M.fn.call(L, B, M.obj) | |
| } catch (F) { | |
| this.lastError = F; | |
| if (A) { | |
| throw F | |
| } | |
| } | |
| } else { | |
| try { | |
| G = M.fn.call(L, this.type, I, M.obj) | |
| } catch (H) { | |
| this.lastError = H; | |
| if (A) { | |
| throw H | |
| } | |
| } | |
| } | |
| if (false === G) { | |
| if (!this.silent) {} | |
| break | |
| } | |
| } | |
| } | |
| return (G !== false) | |
| }, | |
| unsubscribeAll: function () { | |
| var A = this.subscribers.length, | |
| B; | |
| for (B = A - 1; B > -1; B--) { | |
| this._delete(B) | |
| } | |
| this.subscribers = []; | |
| return A | |
| }, | |
| _delete: function (A) { | |
| var B = this.subscribers[A]; | |
| if (B) { | |
| delete B.fn; | |
| delete B.obj | |
| } | |
| this.subscribers.splice(A, 1) | |
| }, | |
| toString: function () { | |
| return "CustomEvent: '" + this.type + "', context: " + this.scope | |
| } | |
| }; | |
| YAHOO.util.Subscriber = function (A, B, C) { | |
| this.fn = A; | |
| this.obj = YAHOO.lang.isUndefined(B) ? null : B; | |
| this.overrideContext = C | |
| }; | |
| YAHOO.util.Subscriber.prototype.getScope = function (A) { | |
| if (this.overrideContext) { | |
| if (this.overrideContext === true) { | |
| return this.obj | |
| } else { | |
| return this.overrideContext | |
| } | |
| } | |
| return A | |
| }; | |
| YAHOO.util.Subscriber.prototype.contains = function (A, B) { | |
| if (B) { | |
| return (this.fn == A && this.obj == B) | |
| } else { | |
| return (this.fn == A) | |
| } | |
| }; | |
| YAHOO.util.Subscriber.prototype.toString = function () { | |
| return "Subscriber { obj: " + this.obj + ", overrideContext: " + (this.overrideContext || "no") + " }" | |
| }; | |
| if (!YAHOO.util.Event) { | |
| YAHOO.util.Event = function () { | |
| var H = false; | |
| var I = []; | |
| var J = []; | |
| var G = []; | |
| var E = []; | |
| var C = 0; | |
| var F = []; | |
| var B = []; | |
| var A = 0; | |
| var D = { | |
| 63232: 38, | |
| 63233: 40, | |
| 63234: 37, | |
| 63235: 39, | |
| 63276: 33, | |
| 63277: 34, | |
| 25: 9 | |
| }; | |
| var K = YAHOO.env.ua.ie ? "focusin" : "focus"; | |
| var L = YAHOO.env.ua.ie ? "focusout" : "blur"; | |
| return { | |
| POLL_RETRYS: 2000, | |
| POLL_INTERVAL: 20, | |
| EL: 0, | |
| TYPE: 1, | |
| FN: 2, | |
| WFN: 3, | |
| UNLOAD_OBJ: 3, | |
| ADJ_SCOPE: 4, | |
| OBJ: 5, | |
| OVERRIDE: 6, | |
| lastError: null, | |
| isSafari: YAHOO.env.ua.webkit, | |
| webkit: YAHOO.env.ua.webkit, | |
| isIE: YAHOO.env.ua.ie, | |
| _interval: null, | |
| _dri: null, | |
| DOMReady: false, | |
| throwErrors: false, | |
| startInterval: function () { | |
| if (!this._interval) { | |
| var M = this; | |
| var N = function () { | |
| M._tryPreloadAttach() | |
| }; | |
| this._interval = setInterval(N, this.POLL_INTERVAL) | |
| } | |
| }, | |
| onAvailable: function (S, O, Q, R, P) { | |
| var M = (YAHOO.lang.isString(S)) ? [S] : S; | |
| for (var N = 0; N < M.length; N = N + 1) { | |
| F.push({ | |
| id: M[N], | |
| fn: O, | |
| obj: Q, | |
| overrideContext: R, | |
| checkReady: P | |
| }) | |
| } | |
| C = this.POLL_RETRYS; | |
| this.startInterval() | |
| }, | |
| onContentReady: function (P, M, N, O) { | |
| this.onAvailable(P, M, N, O, true) | |
| }, | |
| onDOMReady: function (M, N, O) { | |
| if (this.DOMReady) { | |
| setTimeout(function () { | |
| var P = window; | |
| if (O) { | |
| if (O === true) { | |
| P = N | |
| } else { | |
| P = O | |
| } | |
| } | |
| M.call(P, "DOMReady", [], N) | |
| }, 0) | |
| } else { | |
| this.DOMReadyEvent.subscribe(M, N, O) | |
| } | |
| }, | |
| _addListener: function (O, M, Y, S, W, b) { | |
| if (!Y || !Y.call) { | |
| return false | |
| } | |
| if (this._isValidCollection(O)) { | |
| var Z = true; | |
| for (var T = 0, V = O.length; T < V; ++T) { | |
| Z = this.on(O[T], M, Y, S, W) && Z | |
| } | |
| return Z | |
| } else { | |
| if (YAHOO.lang.isString(O)) { | |
| var R = this.getEl(O); | |
| if (R) { | |
| O = R | |
| } else { | |
| this.onAvailable(O, function () { | |
| YAHOO.util.Event.on(O, M, Y, S, W) | |
| }); | |
| return true | |
| } | |
| } | |
| } | |
| if (!O) { | |
| return false | |
| } | |
| if ("unload" == M && S !== this) { | |
| J[J.length] = [O, M, Y, S, W]; | |
| return true | |
| } | |
| var N = O; | |
| if (W) { | |
| if (W === true) { | |
| N = S | |
| } else { | |
| N = W | |
| } | |
| } | |
| var P = function (c) { | |
| return Y.call(N, YAHOO.util.Event.getEvent(c, O), S) | |
| }; | |
| var a = [O, M, Y, P, N, S, W]; | |
| var U = I.length; | |
| I[U] = a; | |
| if (this.useLegacyEvent(O, M)) { | |
| var Q = this.getLegacyIndex(O, M); | |
| if (Q == -1 || O != G[Q][0]) { | |
| Q = G.length; | |
| B[O.id + M] = Q; | |
| G[Q] = [O, M, O["on" + M]]; | |
| E[Q] = []; | |
| O["on" + M] = function (c) { | |
| YAHOO.util.Event.fireLegacyEvent(YAHOO.util.Event.getEvent(c), Q) | |
| } | |
| } | |
| E[Q].push(a) | |
| } else { | |
| try { | |
| this._simpleAdd(O, M, P, b) | |
| } catch (X) { | |
| this.lastError = X; | |
| this.removeListener(O, M, Y); | |
| return false | |
| } | |
| } | |
| return true | |
| }, | |
| addListener: function (N, Q, M, O, P) { | |
| return this._addListener(N, Q, M, O, P, false) | |
| }, | |
| addFocusListener: function (N, M, O, P) { | |
| return this._addListener(N, K, M, O, P, true) | |
| }, | |
| removeFocusListener: function (N, M) { | |
| return this.removeListener(N, K, M) | |
| }, | |
| addBlurListener: function (N, M, O, P) { | |
| return this._addListener(N, L, M, O, P, true) | |
| }, | |
| removeBlurListener: function (N, M) { | |
| return this.removeListener(N, L, M) | |
| }, | |
| fireLegacyEvent: function (R, P) { | |
| var T = true, | |
| M, V, U, N, S; | |
| V = E[P].slice(); | |
| for (var O = 0, Q = V.length; O < Q; ++O) { | |
| U = V[O]; | |
| if (U && U[this.WFN]) { | |
| N = U[this.ADJ_SCOPE]; | |
| S = U[this.WFN].call(N, R); | |
| T = (T && S) | |
| } | |
| } | |
| M = G[P]; | |
| if (M && M[2]) { | |
| M[2](R) | |
| } | |
| return T | |
| }, | |
| getLegacyIndex: function (N, O) { | |
| var M = this.generateId(N) + O; | |
| if (typeof B[M] == "undefined") { | |
| return -1 | |
| } else { | |
| return B[M] | |
| } | |
| }, | |
| useLegacyEvent: function (M, N) { | |
| return (this.webkit && this.webkit < 419 && ("click" == N || "dblclick" == N)) | |
| }, | |
| removeListener: function (N, M, V) { | |
| var Q, T, X; | |
| if (typeof N == "string") { | |
| N = this.getEl(N) | |
| } else { | |
| if (this._isValidCollection(N)) { | |
| var W = true; | |
| for (Q = N.length - 1; Q > -1; Q--) { | |
| W = (this.removeListener(N[Q], M, V) && W) | |
| } | |
| return W | |
| } | |
| } | |
| if (!V || !V.call) { | |
| return this.purgeElement(N, false, M) | |
| } | |
| if ("unload" == M) { | |
| for (Q = J.length - 1; Q > -1; Q--) { | |
| X = J[Q]; | |
| if (X && X[0] == N && X[1] == M && X[2] == V) { | |
| J.splice(Q, 1); | |
| return true | |
| } | |
| } | |
| return false | |
| } | |
| var R = null; | |
| var S = arguments[3]; | |
| if ("undefined" === typeof S) { | |
| S = this._getCacheIndex(N, M, V) | |
| } | |
| if (S >= 0) { | |
| R = I[S] | |
| } | |
| if (!N || !R) { | |
| return false | |
| } | |
| if (this.useLegacyEvent(N, M)) { | |
| var P = this.getLegacyIndex(N, M); | |
| var O = E[P]; | |
| if (O) { | |
| for (Q = 0, T = O.length; Q < T; ++Q) { | |
| X = O[Q]; | |
| if (X && X[this.EL] == N && X[this.TYPE] == M && X[this.FN] == V) { | |
| O.splice(Q, 1); | |
| break | |
| } | |
| } | |
| } | |
| } else { | |
| try { | |
| this._simpleRemove(N, M, R[this.WFN], false) | |
| } catch (U) { | |
| this.lastError = U; | |
| return false | |
| } | |
| } | |
| delete I[S][this.WFN]; | |
| delete I[S][this.FN]; | |
| I.splice(S, 1); | |
| return true | |
| }, | |
| getTarget: function (O, N) { | |
| var M = O.target || O.srcElement; | |
| return this.resolveTextNode(M) | |
| }, | |
| resolveTextNode: function (N) { | |
| try { | |
| if (N && 3 == N.nodeType) { | |
| return N.parentNode | |
| } | |
| } catch (M) {} | |
| return N | |
| }, | |
| getPageX: function (N) { | |
| var M = N.pageX; | |
| if (!M && 0 !== M) { | |
| M = N.clientX || 0; | |
| if (this.isIE) { | |
| M += this._getScrollLeft() | |
| } | |
| } | |
| return M | |
| }, | |
| getPageY: function (M) { | |
| var N = M.pageY; | |
| if (!N && 0 !== N) { | |
| N = M.clientY || 0; | |
| if (this.isIE) { | |
| N += this._getScrollTop() | |
| } | |
| } | |
| return N | |
| }, | |
| getXY: function (M) { | |
| return [this.getPageX(M), this.getPageY(M)] | |
| }, | |
| getRelatedTarget: function (N) { | |
| var M = N.relatedTarget; | |
| if (!M) { | |
| if (N.type == "mouseout") { | |
| M = N.toElement | |
| } else { | |
| if (N.type == "mouseover") { | |
| M = N.fromElement | |
| } | |
| } | |
| } | |
| return this.resolveTextNode(M) | |
| }, | |
| getTime: function (O) { | |
| if (!O.time) { | |
| var N = new Date() | |
| .getTime(); | |
| try { | |
| O.time = N | |
| } catch (M) { | |
| this.lastError = M; | |
| return N | |
| } | |
| } | |
| return O.time | |
| }, | |
| stopEvent: function (M) { | |
| this.stopPropagation(M); | |
| this.preventDefault(M) | |
| }, | |
| stopPropagation: function (M) { | |
| if (M.stopPropagation) { | |
| M.stopPropagation() | |
| } else { | |
| M.cancelBubble = true | |
| } | |
| }, | |
| preventDefault: function (M) { | |
| if (M.preventDefault) { | |
| M.preventDefault() | |
| } else { | |
| M.returnValue = false | |
| } | |
| }, | |
| getEvent: function (O, M) { | |
| var N = O || window.event; | |
| if (!N) { | |
| var P = this.getEvent.caller; | |
| while (P) { | |
| N = P.arguments[0]; | |
| if (N && Event == N.constructor) { | |
| break | |
| } | |
| P = P.caller | |
| } | |
| } | |
| return N | |
| }, | |
| getCharCode: function (N) { | |
| var M = N.keyCode || N.charCode || 0; | |
| if (YAHOO.env.ua.webkit && (M in D)) { | |
| M = D[M] | |
| } | |
| return M | |
| }, | |
| _getCacheIndex: function (Q, R, P) { | |
| for (var O = 0, N = I.length; O < N; O = O + 1) { | |
| var M = I[O]; | |
| if (M && M[this.FN] == P && M[this.EL] == Q && M[this.TYPE] == R) { | |
| return O | |
| } | |
| } | |
| return -1 | |
| }, | |
| generateId: function (M) { | |
| var N = M.id; | |
| if (!N) { | |
| N = "yuievtautoid-" + A; | |
| ++A; | |
| M.id = N | |
| } | |
| return N | |
| }, | |
| _isValidCollection: function (N) { | |
| try { | |
| return (N && typeof N !== "string" && N.length && !N.tagName && !N.alert && typeof N[0] !== "undefined") | |
| } catch (M) { | |
| return false | |
| } | |
| }, | |
| elCache: {}, | |
| getEl: function (M) { | |
| return (typeof M === "string") ? document.getElementById(M) : M | |
| }, | |
| clearCache: function () {}, | |
| DOMReadyEvent: new YAHOO.util.CustomEvent("DOMReady", this), | |
| _load: function (N) { | |
| if (!H) { | |
| H = true; | |
| var M = YAHOO.util.Event; | |
| M._ready(); | |
| M._tryPreloadAttach() | |
| } | |
| }, | |
| _ready: function (N) { | |
| var M = YAHOO.util.Event; | |
| if (!M.DOMReady) { | |
| M.DOMReady = true; | |
| M.DOMReadyEvent.fire(); | |
| M._simpleRemove(document, "DOMContentLoaded", M._ready) | |
| } | |
| }, | |
| _tryPreloadAttach: function () { | |
| if (F.length === 0) { | |
| C = 0; | |
| if (this._interval) { | |
| clearInterval(this._interval); | |
| this._interval = null | |
| } | |
| return | |
| } | |
| if (this.locked) { | |
| return | |
| } | |
| if (this.isIE) { | |
| if (!this.DOMReady) { | |
| this.startInterval(); | |
| return | |
| } | |
| } | |
| this.locked = true; | |
| var S = !H; | |
| if (!S) { | |
| S = (C > 0 && F.length > 0) | |
| } | |
| var R = []; | |
| var T = function (V, W) { | |
| var U = V; | |
| if (W.overrideContext) { | |
| if (W.overrideContext === true) { | |
| U = W.obj | |
| } else { | |
| U = W.overrideContext | |
| } | |
| } | |
| W.fn.call(U, W.obj) | |
| }; | |
| var N, M, Q, P, O = []; | |
| for (N = 0, M = F.length; N < M; N = N + 1) { | |
| Q = F[N]; | |
| if (Q) { | |
| P = this.getEl(Q.id); | |
| if (P) { | |
| if (Q.checkReady) { | |
| if (H || P.nextSibling || !S) { | |
| O.push(Q); | |
| F[N] = null | |
| } | |
| } else { | |
| T(P, Q); | |
| F[N] = null | |
| } | |
| } else { | |
| R.push(Q) | |
| } | |
| } | |
| } | |
| for (N = 0, M = O.length; N < M; N = N + 1) { | |
| Q = O[N]; | |
| T(this.getEl(Q.id), Q) | |
| } | |
| C--; | |
| if (S) { | |
| for (N = F.length - 1; N > -1; N--) { | |
| Q = F[N]; | |
| if (!Q || !Q.id) { | |
| F.splice(N, 1) | |
| } | |
| } | |
| this.startInterval() | |
| } else { | |
| if (this._interval) { | |
| clearInterval(this._interval); | |
| this._interval = null | |
| } | |
| } | |
| this.locked = false | |
| }, | |
| purgeElement: function (Q, R, T) { | |
| var O = (YAHOO.lang.isString(Q)) ? this.getEl(Q) : Q; | |
| var S = this.getListeners(O, T), | |
| P, M; | |
| if (S) { | |
| for (P = S.length - 1; P > -1; P--) { | |
| var N = S[P]; | |
| this.removeListener(O, N.type, N.fn) | |
| } | |
| } | |
| if (R && O && O.childNodes) { | |
| for (P = 0, M = O.childNodes.length; P < M; ++P) { | |
| this.purgeElement(O.childNodes[P], R, T) | |
| } | |
| } | |
| }, | |
| getListeners: function (O, M) { | |
| var R = [], | |
| N; | |
| if (!M) { | |
| N = [I, J] | |
| } else { | |
| if (M === "unload") { | |
| N = [J] | |
| } else { | |
| N = [I] | |
| } | |
| } | |
| var T = (YAHOO.lang.isString(O)) ? this.getEl(O) : O; | |
| for (var Q = 0; Q < N.length; Q = Q + 1) { | |
| var V = N[Q]; | |
| if (V) { | |
| for (var S = 0, U = V.length; S < U; ++S) { | |
| var P = V[S]; | |
| if (P && P[this.EL] === T && (!M || M === P[this.TYPE])) { | |
| R.push({ | |
| type: P[this.TYPE], | |
| fn: P[this.FN], | |
| obj: P[this.OBJ], | |
| adjust: P[this.OVERRIDE], | |
| scope: P[this.ADJ_SCOPE], | |
| index: S | |
| }) | |
| } | |
| } | |
| } | |
| } | |
| return (R.length) ? R : null | |
| }, | |
| _unload: function (T) { | |
| var N = YAHOO.util.Event, | |
| Q, P, O, S, R, U = J.slice(), | |
| M; | |
| for (Q = 0, S = J.length; Q < S; ++Q) { | |
| O = U[Q]; | |
| if (O) { | |
| M = window; | |
| if (O[N.ADJ_SCOPE]) { | |
| if (O[N.ADJ_SCOPE] === true) { | |
| M = O[N.UNLOAD_OBJ] | |
| } else { | |
| M = O[N.ADJ_SCOPE] | |
| } | |
| } | |
| O[N.FN].call(M, N.getEvent(T, O[N.EL]), O[N.UNLOAD_OBJ]); | |
| U[Q] = null | |
| } | |
| } | |
| O = null; | |
| M = null; | |
| J = null; | |
| if (I) { | |
| for (P = I.length - 1; P > -1; P--) { | |
| O = I[P]; | |
| if (O) { | |
| N.removeListener(O[N.EL], O[N.TYPE], O[N.FN], P) | |
| } | |
| } | |
| O = null | |
| } | |
| G = null; | |
| N._simpleRemove(window, "unload", N._unload) | |
| }, | |
| _getScrollLeft: function () { | |
| return this._getScroll()[1] | |
| }, | |
| _getScrollTop: function () { | |
| return this._getScroll()[0] | |
| }, | |
| _getScroll: function () { | |
| var M = document.documentElement, | |
| N = document.body; | |
| if (M && (M.scrollTop || M.scrollLeft)) { | |
| return [M.scrollTop, M.scrollLeft] | |
| } else { | |
| if (N) { | |
| return [N.scrollTop, N.scrollLeft] | |
| } else { | |
| return [0, 0] | |
| } | |
| } | |
| }, | |
| regCE: function () {}, | |
| _simpleAdd: function () { | |
| if (window.addEventListener) { | |
| return function (O, P, N, M) { | |
| O.addEventListener(P, N, (M)) | |
| } | |
| } else { | |
| if (window.attachEvent) { | |
| return function (O, P, N, M) { | |
| O.attachEvent("on" + P, N) | |
| } | |
| } else { | |
| return function () {} | |
| } | |
| } | |
| }(), | |
| _simpleRemove: function () { | |
| if (window.removeEventListener) { | |
| return function (O, P, N, M) { | |
| O.removeEventListener(P, N, (M)) | |
| } | |
| } else { | |
| if (window.detachEvent) { | |
| return function (N, O, M) { | |
| N.detachEvent("on" + O, M) | |
| } | |
| } else { | |
| return function () {} | |
| } | |
| } | |
| }() | |
| } | |
| }(); | |
| (function () { | |
| var EU = YAHOO.util.Event; | |
| EU.on = EU.addListener; | |
| EU.onFocus = EU.addFocusListener; | |
| EU.onBlur = EU.addBlurListener; | |
| if (EU.isIE) { | |
| YAHOO.util.Event.onDOMReady(YAHOO.util.Event._tryPreloadAttach, YAHOO.util.Event, true); | |
| var n = document.createElement("p"); | |
| EU._dri = setInterval(function () { | |
| try { | |
| n.doScroll("left"); | |
| clearInterval(EU._dri); | |
| EU._dri = null; | |
| EU._ready(); | |
| n = null | |
| } catch (ex) {} | |
| }, EU.POLL_INTERVAL) | |
| } else { | |
| if (EU.webkit && EU.webkit < 525) { | |
| EU._dri = setInterval(function () { | |
| var rs = document.readyState; | |
| if ("loaded" == rs || "complete" == rs) { | |
| clearInterval(EU._dri); | |
| EU._dri = null; | |
| EU._ready() | |
| } | |
| }, EU.POLL_INTERVAL) | |
| } else { | |
| EU._simpleAdd(document, "DOMContentLoaded", EU._ready) | |
| } | |
| } | |
| EU._simpleAdd(window, "load", EU._load); | |
| EU._simpleAdd(window, "unload", EU._unload); | |
| EU._tryPreloadAttach() | |
| })() | |
| } | |
| YAHOO.util.EventProvider = function () {}; | |
| YAHOO.util.EventProvider.prototype = { | |
| __yui_events: null, | |
| __yui_subscribers: null, | |
| subscribe: function (A, C, F, E) { | |
| this.__yui_events = this.__yui_events || {}; | |
| var D = this.__yui_events[A]; | |
| if (D) { | |
| D.subscribe(C, F, E) | |
| } else { | |
| this.__yui_subscribers = this.__yui_subscribers || {}; | |
| var B = this.__yui_subscribers; | |
| if (!B[A]) { | |
| B[A] = [] | |
| } | |
| B[A].push({ | |
| fn: C, | |
| obj: F, | |
| overrideContext: E | |
| }) | |
| } | |
| }, | |
| unsubscribe: function (C, E, G) { | |
| this.__yui_events = this.__yui_events || {}; | |
| var A = this.__yui_events; | |
| if (C) { | |
| var F = A[C]; | |
| if (F) { | |
| return F.unsubscribe(E, G) | |
| } | |
| } else { | |
| var B = true; | |
| for (var D in A) { | |
| if (YAHOO.lang.hasOwnProperty(A, D)) { | |
| B = B && A[D].unsubscribe(E, G) | |
| } | |
| } | |
| return B | |
| } | |
| return false | |
| }, | |
| unsubscribeAll: function (A) { | |
| return this.unsubscribe(A) | |
| }, | |
| createEvent: function (G, D) { | |
| this.__yui_events = this.__yui_events || {}; | |
| var A = D || {}; | |
| var I = this.__yui_events; | |
| if (I[G]) {} else { | |
| var H = A.scope || this; | |
| var E = (A.silent); | |
| var B = new YAHOO.util.CustomEvent(G, H, E, YAHOO.util.CustomEvent.FLAT); | |
| I[G] = B; | |
| if (A.onSubscribeCallback) { | |
| B.subscribeEvent.subscribe(A.onSubscribeCallback) | |
| } | |
| this.__yui_subscribers = this.__yui_subscribers || {}; | |
| var F = this.__yui_subscribers[G]; | |
| if (F) { | |
| for (var C = 0; C < F.length; ++C) { | |
| B.subscribe(F[C].fn, F[C].obj, F[C].overrideContext) | |
| } | |
| } | |
| } | |
| return I[G] | |
| }, | |
| fireEvent: function (E, D, A, C) { | |
| this.__yui_events = this.__yui_events || {}; | |
| var G = this.__yui_events[E]; | |
| if (!G) { | |
| return null | |
| } | |
| var B = []; | |
| for (var F = 1; F < arguments.length; ++F) { | |
| B.push(arguments[F]) | |
| } | |
| return G.fire.apply(G, B) | |
| }, | |
| hasEvent: function (A) { | |
| if (this.__yui_events) { | |
| if (this.__yui_events[A]) { | |
| return true | |
| } | |
| } | |
| return false | |
| } | |
| }; | |
| (function () { | |
| var A = YAHOO.util.Event, | |
| C = YAHOO.lang; | |
| YAHOO.util.KeyListener = function (D, I, E, F) { | |
| if (!D) {} else { | |
| if (!I) {} else { | |
| if (!E) {} | |
| } | |
| } | |
| if (!F) { | |
| F = YAHOO.util.KeyListener.KEYDOWN | |
| } | |
| var G = new YAHOO.util.CustomEvent("keyPressed"); | |
| this.enabledEvent = new YAHOO.util.CustomEvent("enabled"); | |
| this.disabledEvent = new YAHOO.util.CustomEvent("disabled"); | |
| if (C.isString(D)) { | |
| D = document.getElementById(D) | |
| } | |
| if (C.isFunction(E)) { | |
| G.subscribe(E) | |
| } else { | |
| G.subscribe(E.fn, E.scope, E.correctScope) | |
| } | |
| function H(O, N) { | |
| if (!I.shift) { | |
| I.shift = false | |
| } | |
| if (!I.alt) { | |
| I.alt = false | |
| } | |
| if (!I.ctrl) { | |
| I.ctrl = false | |
| } | |
| if (O.shiftKey == I.shift && O.altKey == I.alt && O.ctrlKey == I.ctrl) { | |
| var J, M = I.keys, | |
| L; | |
| if (YAHOO.lang.isArray(M)) { | |
| for (var K = 0; K < M.length; K++) { | |
| J = M[K]; | |
| L = A.getCharCode(O); | |
| if (J == L) { | |
| G.fire(L, O); | |
| break | |
| } | |
| } | |
| } else { | |
| L = A.getCharCode(O); | |
| if (M == L) { | |
| G.fire(L, O) | |
| } | |
| } | |
| } | |
| } | |
| this.enable = function () { | |
| if (!this.enabled) { | |
| A.on(D, F, H); | |
| this.enabledEvent.fire(I) | |
| } | |
| this.enabled = true | |
| }; | |
| this.disable = function () { | |
| if (this.enabled) { | |
| A.removeListener(D, F, H); | |
| this.disabledEvent.fire(I) | |
| } | |
| this.enabled = false | |
| }; | |
| this.toString = function () { | |
| return "KeyListener [" + I.keys + "] " + D.tagName + (D.id ? "[" + D.id + "]" : "") | |
| } | |
| }; | |
| var B = YAHOO.util.KeyListener; | |
| B.KEYDOWN = "keydown"; | |
| B.KEYUP = "keyup"; | |
| B.KEY = { | |
| ALT: 18, | |
| BACK_SPACE: 8, | |
| CAPS_LOCK: 20, | |
| CONTROL: 17, | |
| DELETE: 46, | |
| DOWN: 40, | |
| END: 35, | |
| ENTER: 13, | |
| ESCAPE: 27, | |
| HOME: 36, | |
| LEFT: 37, | |
| META: 224, | |
| NUM_LOCK: 144, | |
| PAGE_DOWN: 34, | |
| PAGE_UP: 33, | |
| PAUSE: 19, | |
| PRINTSCREEN: 44, | |
| RIGHT: 39, | |
| SCROLL_LOCK: 145, | |
| SHIFT: 16, | |
| SPACE: 32, | |
| TAB: 9, | |
| UP: 38 | |
| } | |
| })(); | |
| YAHOO.register("event", YAHOO.util.Event, { | |
| version: "2.7.0", | |
| build: "1796" | |
| }); | |
| YAHOO.namespace("YAHOO.Groups.framework"); | |
| YAHOO.Groups.framework.Base = function () { | |
| var oOverriddenMethods = {}; | |
| var iSuperLevel = -1; | |
| var getArgumentsString = function (pArgs, pIdx, pVar) { | |
| var s = "", | |
| len = pArgs.length, | |
| i; | |
| for (i = pIdx; i < len; i++) { | |
| s += pVar + "[" + i + "]," | |
| } | |
| if (len > 1) { | |
| s = s.substring(0, s.length - 1) | |
| } | |
| return s | |
| }; | |
| var oThis = { | |
| override: function (pName, pMethod) { | |
| if (!oOverriddenMethods[pName]) { | |
| oOverriddenMethods[pName] = [] | |
| } | |
| var len = oOverriddenMethods[pName].length, | |
| n = pName + len; | |
| oOverriddenMethods[pName][len] = n; | |
| eval("oThis." + n + "=oThis." + pName); | |
| eval("oThis." + pName + "=pMethod") | |
| }, | |
| superMethod: function (pName) { | |
| if (iSuperLevel == -1) { | |
| iSuperLevel = oOverriddenMethods[pName].length - 1 | |
| } | |
| var rv = eval("oThis." + oOverriddenMethods[pName][iSuperLevel--] + "(" + getArgumentsString(arguments, 1, "arguments") + ")"); | |
| iSuperLevel = -1; | |
| return rv | |
| } | |
| }; | |
| return oThis | |
| }; | |
| YAHOO.namespace("YAHOO.Groups.framework"); | |
| YAHOO.Groups.framework.Html = function (pId, pElement) { | |
| var $D = document; | |
| var formatPosition = function (pPos) { | |
| var pos = new String(pPos); | |
| if (!pos.has("%", "px")) { | |
| pos += "px" | |
| } | |
| return pos | |
| }; | |
| var setLTWH = function (pType, pVal, pIsPos) { | |
| if ((pVal != null) && (pIsPos || (pVal > -1))) { | |
| eval("oThis.oElem.style." + pType.toLowerCase() + "='" + formatPosition(pVal) + "';") | |
| } | |
| return parseInt(eval("oThis.oElem.offset" + pType)) | |
| }; | |
| var oThis = { | |
| oElem: pElement || $D.getElementById(pId), | |
| left: function (pLeft) { | |
| return setLTWH("Left", pLeft, true) | |
| }, | |
| top: function (pTop) { | |
| return setLTWH("Top", pTop, true) | |
| }, | |
| width: function (pWidth) { | |
| return setLTWH("Width", pWidth) | |
| }, | |
| height: function (pHeight) { | |
| return setLTWH("Height", pHeight) | |
| }, | |
| display: function (pDisplay) { | |
| oThis.oElem.style.display = pDisplay ? "" : "none" | |
| }, | |
| show: function (pShow) { | |
| oThis.oElem.style.visibility = pShow ? "" : "hidden" | |
| }, | |
| addClass: function (pClass) { | |
| oThis.removeClass(pClass); | |
| var cl = oThis.oElem.className; | |
| if (cl.is("")) { | |
| oThis.oElem.className = pClass | |
| } else { | |
| oThis.oElem.className += " " + pClass | |
| } | |
| }, | |
| removeClass: function (pClass) { | |
| var cl = oThis.oElem.className.split(" "); | |
| var nc = ""; | |
| for (var i = 0, len = cl.length; i < len; i++) { | |
| if (!cl[i].is(pClass)) { | |
| nc += nc.length ? " " : ""; | |
| nc += cl[i] | |
| } | |
| } | |
| oThis.oElem.className = nc | |
| }, | |
| html: function (pVal) { | |
| oThis.oElem.innerHTML = pVal | |
| } | |
| }; | |
| return oThis | |
| }; | |
| YAHOO.namespace("YAHOO.Groups.framework"); | |
| YAHOO.Groups.framework.Dialog = function (pUrl, pData, pType) { | |
| var oThis = { | |
| oDialogLayer: YAHOO.Groups.framework.Html("dynamic_dialog_div"), | |
| oTransparentLayer: YAHOO.Groups.framework.Html("dialog_transparent_div"), | |
| oLoadingLayer: YAHOO.Groups.framework.Html("dynamic_dialog_loading_div"), | |
| oBodyLayer: YAHOO.Groups.framework.Html("dynamic_dialog_body_div"), | |
| sType: pType || "POST", | |
| init: function () { | |
| var newDialogLayer = YAHOO.util.Dom.get("dynamic_dialog_div") | |
| .cloneNode(true); | |
| var parentNode = YAHOO.util.Dom.get("dynamic_dialog_div") | |
| .parentNode; | |
| parentNode.removeChild(YAHOO.util.Dom.get("dynamic_dialog_div")); | |
| var bodyDiv = YAHOO.util.Dom.get("dialog_transparent_div") | |
| .parentNode; | |
| bodyDiv.appendChild(newDialogLayer); | |
| oThis.oDialogLayer = YAHOO.Groups.framework.Html("dynamic_dialog_div"); | |
| oThis.oTransparentLayer.display(true); | |
| oThis.oDialogLayer.display(true); | |
| oThis.oLoadingLayer.display(true); | |
| oThis.oBodyLayer.display(); | |
| oThis.center(); | |
| YAHOO.util.Event.addListener(window, "resize", oThis.center); | |
| YAHOO.Groups.framework.ajax.Server.addRequest(YAHOO.Groups.framework.ajax.Request(oThis.onAjaxResponse, pUrl, pData, pType)) | |
| }, | |
| onAjaxResponse: function (pResponse) { | |
| YAHOO.util.Dom.get("dynamic_dialog_body_div") | |
| .innerHTML = pResponse.responseText; | |
| YAHOO.util.Dom.setStyle("dynamic_dialog_loading_div", "display", "none"); | |
| YAHOO.util.Dom.setStyle("dynamic_dialog_body_div", "display", "block") | |
| }, | |
| display: function (pDisplay) { | |
| if (pDisplay) { | |
| oThis.oLoadingLayer.display(); | |
| oThis.oBodyLayer.display(true); | |
| oThis.center() | |
| } else { | |
| oThis.oTransparentLayer.display(); | |
| oThis.oDialogLayer.display() | |
| } | |
| }, | |
| center: function () { | |
| var fdw = oThis.getFullDocWidth(), | |
| vdw = oThis.getVisibleDocWidth(), | |
| fdh = oThis.getFullDocHeight(), | |
| vdh = oThis.getVisibleDocHeight(), | |
| dt = oThis.getDocScrollTop(); | |
| var l = oThis.oTransparentLayer; | |
| l.width(fdw); | |
| l.height(fdh); | |
| l.top(0); | |
| l = oThis.oDialogLayer; | |
| l.left(vdw / 2 - l.width() / 2); | |
| l.top(vdh / 2 - l.height() / 2 + dt) | |
| }, | |
| getVisibleDocWidth: function () { | |
| var w = window.innerWidth; | |
| return (typeof (w) != "number") ? document.documentElement.offsetWidth : w | |
| }, | |
| getFullDocWidth: function () { | |
| return document.body.offsetWidth | |
| }, | |
| getVisibleDocHeight: function () { | |
| var h = window.innerHeight; | |
| return (typeof (h) != "number") ? document.documentElement.offsetHeight : h | |
| }, | |
| getFullDocHeight: function () { | |
| return document.body.offsetHeight | |
| }, | |
| getDocScrollTop: function () { | |
| return document.documentElement.scrollTop || document.body.scrollTop | |
| } | |
| }; | |
| oThis.init(); | |
| return oThis | |
| }; | |
| YAHOO.namespace("YAHOO.Groups.lib.dialogs"); | |
| YAHOO.Groups.lib.dialogs.OkCancel = function (pUrl, pData, pOkListener, pCancelListener, pManualCloseOnOk) { | |
| var oThis = YAHOO.Groups.framework.Dialog(pUrl, pData); | |
| oThis.onOkClick = function (pEvent) { | |
| if (pOkListener) { | |
| pOkListener(oThis) | |
| } | |
| if (!pManualCloseOnOk) { | |
| oThis.display() | |
| } | |
| YAHOO.util.Event.preventDefault(pEvent); | |
| return false | |
| }; | |
| oThis.onCancelClick = function (pEvent) { | |
| if (pCancelListener) { | |
| pCancelListener(oThis) | |
| } | |
| oThis.display(); | |
| YAHOO.util.Event.preventDefault(pEvent); | |
| return false | |
| }; | |
| oThis.init = function (pOkId, pCancelId) { | |
| YAHOO.util.Event.addListener(document.getElementById(pOkId), "click", oThis.onOkClick); | |
| YAHOO.util.Event.addListener(document.getElementById(pCancelId), "click", oThis.onCancelClick) | |
| }; | |
| return oThis | |
| }; | |
| YAHOO.namespace("YAHOO.Groups.framework.ajax"); | |
| YAHOO.Groups.framework.ajax.Request = function (pCallback, pUrl, pData, pType, pHeaders, pHighPriority) { | |
| var oThis = { | |
| fCallback: pCallback, | |
| sUrl: pUrl, | |
| oData: pData, | |
| sType: pType || "POST", | |
| aHeaders: pHeaders || [], | |
| bHighPriority: pHighPriority, | |
| init: function () { | |
| oThis.aHeaders["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8" | |
| }, | |
| getUrl: function () { | |
| return oThis.sUrl | |
| }, | |
| getData: function () { | |
| var d = oThis.oData, | |
| s = ""; | |
| for (var key in d) { | |
| if (d[key] == null) { | |
| continue | |
| } | |
| if (s.length != 0) { | |
| s += "&" | |
| } | |
| s += encodeURIComponent(key) + "=" + encodeURIComponent(d[key]) | |
| } | |
| return s | |
| }, | |
| handleException: function (pException) {}, | |
| processResponse: function (pConnection) { | |
| oThis.fCallback(pConnection, this) | |
| } | |
| }; | |
| oThis.init(); | |
| return oThis | |
| }; | |
| YAHOO.namespace("YAHOO.Groups.framework.ajax"); | |
| YAHOO.Groups.framework.ajax.Server = new function () { | |
| var aRequests = [], | |
| oCurrentRequest = null, | |
| oConnection = null, | |
| bWaitingOnResponse = false; | |
| var oThis = { | |
| addRequest: function (pReq) { | |
| aRequests.push(pReq); | |
| oThis.sendRequests(); | |
| return pReq | |
| }, | |
| clearRequests: function () { | |
| aRequests = []; | |
| oThis.responseComplete() | |
| }, | |
| sendRequests: function () { | |
| if (!bWaitingOnResponse) { | |
| var req = aRequests.shift(); | |
| if (req) { | |
| oCurrentRequest = req; | |
| oThis.sendRequest(req) | |
| } | |
| } | |
| }, | |
| sendRequest: function (pReq) { | |
| try { | |
| var r = null; | |
| if (typeof (window.XMLHttpRequest) != "undefined") { | |
| r = oConnection = new XMLHttpRequest() | |
| } else { | |
| if (typeof (ActiveXObject) != "undefined") { | |
| r = oConnection = new ActiveXObject("Microsoft.XMLHTTP") | |
| } | |
| } | |
| if (r) { | |
| bWaitingOnResponse = true; | |
| r.open(pReq.sType, pReq.getUrl(), true); | |
| for (var i in pReq.aHeaders) { | |
| if (typeof pReq.aHeaders[i] != "function") { | |
| r.setRequestHeader(i, pReq.aHeaders[i]) | |
| } | |
| } | |
| r.onreadystatechange = oThis.callback; | |
| r.send(pReq.getData()) | |
| } | |
| } catch (e) { | |
| oThis.handleException(e) | |
| } | |
| }, | |
| callback: function () { | |
| if (oConnection && (oConnection.readyState == 4)) { | |
| if (oConnection.status == 404) { | |
| oThis.handleException(oConnection) | |
| } else { | |
| oThis.processResponse() | |
| } | |
| } | |
| }, | |
| processResponse: function () { | |
| oCurrentRequest.processResponse(oConnection); | |
| oThis.responseComplete() | |
| }, | |
| responseComplete: function () { | |
| oConnection = oCurrentRequest = null; | |
| bWaitingOnResponse = false; | |
| oThis.sendRequests() | |
| }, | |
| handleException: function (pObj) { | |
| oCurrentRequest.handleException(pObj); | |
| oThis.responseComplete() | |
| } | |
| }; | |
| return oThis | |
| }; | |
| String.prototype.has = function (pVal) { | |
| return this.indexOf(pVal) != -1 | |
| }; | |
| String.prototype.hasAny = function () { | |
| var len = arguments.length, | |
| i; | |
| for (i = 0; i < len; i++) { | |
| if (this.has(arguments[i])) { | |
| return true | |
| } | |
| } | |
| return false | |
| }; | |
| String.prototype.hasAll = function () { | |
| var len = arguments.length, | |
| i, rv = true; | |
| for (i = 0; rv && i < len; i++) { | |
| rv = this.has(arguments[i]) | |
| } | |
| return rv | |
| }; | |
| String.prototype.is = function (pVal) { | |
| return this == pVal | |
| }; | |
| String.prototype.isAny = function () { | |
| var len = arguments.length, | |
| i; | |
| for (i = 0; i < len; i++) { | |
| if (this.is(arguments[i])) { | |
| return true | |
| } | |
| } | |
| return false | |
| }; | |
| String.prototype.startsWith = function (pVal) { | |
| return this.indexOf(pVal) == 0 | |
| }; | |
| String.prototype.endsWith = function (pVal) { | |
| return this.lastIndexOf(pVal) == (this.length - pVal.length) | |
| }; | |
| String.prototype.trim = function () { | |
| var s = this; | |
| while (s.substring(0, 1) | |
| .isAny(" ", "\n", "\r")) { | |
| s = s.substring(1, s.length) | |
| } | |
| while (s.substring(s.length - 1, s.length) | |
| .isAny(" ", "\n", "\r")) { | |
| s = s.substring(0, s.length - 1) | |
| } | |
| return s | |
| }; | |
| String.prototype.replaceTokens = function () { | |
| var args = arguments, | |
| len = args.length, | |
| tokenPre = "{#", | |
| tokenPost = "#}", | |
| i, s = this; | |
| for (i = 0; i < len; i++) { | |
| s = s.replace(new RegExp(tokenPre + (i + 1) + tokenPost, "g"), args[i]) | |
| } | |
| return s | |
| }; | |
| String.prototype.make2DigitNumber = function () { | |
| return (parseInt(this) < 10) ? ("0" + this) : this | |
| }; | |
| YAHOO.namespace("YAHOO.Groups.lib.dialogs"); | |
| YAHOO.Groups.lib.dialogs.VitalityDialog = function (pGroupName, pCallback) { | |
| var sUrl = "/group/" + pGroupName + "/vitality/settings"; | |
| var sAjaxUrl = "/group/" + pGroupName + "/vitality/ajax_save"; | |
| var sGCookiePath = "/group/" + pGroupName + "/"; | |
| var sCheckboxId = "dontRemindMe"; | |
| var sYcbId = "vitalityCrumb"; | |
| var oCallback = pCallback; | |
| var oThis = { | |
| display: function () { | |
| YAHOO.Groups.oCurrentDialog = YAHOO.Groups.lib.dialogs.OkCancel(sUrl, {}, oThis.onDialogOk, oThis.onDialogCancel, false) | |
| }, | |
| onDialogOk: function () { | |
| var bDontRemindMe = document.getElementById(sCheckboxId) | |
| .checked; | |
| var sYcb = document.getElementById(sYcbId) | |
| .value; | |
| YAHOO.Groups.framework.ajax.Server.addRequest(YAHOO.Groups.framework.ajax.Request(oThis.onAjaxResponse, sAjaxUrl, { | |
| sYcb: sYcb, | |
| bVitalityOn: true, | |
| bDontRemindMe: bDontRemindMe | |
| })); | |
| document.cookie = "G=; domain=." + window.location.host + "; expires=Fri, 3 Aug 2001 20:47:11 UTC; path=" + sGCookiePath; | |
| oCallback(true, bDontRemindMe) | |
| }, | |
| onDialogCancel: function () { | |
| var bDontRemindMe = document.getElementById(sCheckboxId) | |
| .checked; | |
| var sYcb = document.getElementById(sYcbId) | |
| .value; | |
| YAHOO.Groups.framework.ajax.Server.addRequest(YAHOO.Groups.framework.ajax.Request(oThis.onAjaxResponse, sAjaxUrl, { | |
| sYcb: sYcb, | |
| bVitalityOn: false, | |
| bDontRemindMe: bDontRemindMe | |
| })); | |
| document.cookie = "G=; domain=." + window.location.host + "; expires=Fri, 3 Aug 2001 20:47:11 UTC; path=" + sGCookiePath; | |
| oCallback(false, bDontRemindMe) | |
| }, | |
| onAjaxResponse: function (pResponse) { | |
| document.cookie = "G=; domain=." + window.location.host + "; expires=Fri, 3 Aug 2001 20:47:11 UTC; path=" + sGCookiePath | |
| } | |
| }; | |
| oThis.display(); | |
| return oThis | |
| }; | |
| document.documentElement.className += " js"; | |
| YAHOO.namespace("YAHOO.Groups.photos.select.uploader"); | |
| YAHOO.Groups.photos.select.uploader = function (iconDone, completed, uploadLimit, photoLabel, photoNameLabel, sizeLabel, removeLabel, filesLabel, fileLabel, kbLabel, iconError, error, uploadFileSizeLimit, uploadingLabel, uploadingProgressLabel, groupName, containerId, domainName, referenceId, nextView, photosSwf, version, showVitalityDialog, flashRequired, uploadHost) { | |
| var $D = YAHOO.util.Dom; | |
| var $E = YAHOO.util.Event; | |
| var api = { | |
| completed: '<img src="' + iconDone + '" alt="' + completed + '"/>', | |
| dataTableId: null, | |
| errors: [], | |
| fileCount: 0, | |
| fileList: [], | |
| lastRowClass: null, | |
| limit: uploadLimit, | |
| photoNames: [], | |
| sizeTotal: 0, | |
| state: "initial", | |
| successful: 0, | |
| tickets: [], | |
| toRemove: [], | |
| uploader: null, | |
| vitalityOn: 0, | |
| addCommas: function (n) { | |
| n += ""; | |
| x = n.split("."); | |
| x1 = x[0]; | |
| x2 = x.length > 1 ? "." + x[1] : ""; | |
| var regex = /(\d+)(\d{3})/; | |
| while (regex.test(x1)) { | |
| x1 = x1.replace(regex, "$1,$2") | |
| } | |
| return x1 + x2 | |
| }, | |
| createDataTable: function (entries) { | |
| dataArray = []; | |
| fileIdHash = {}; | |
| api.sizeTotal = 0; | |
| if (entries !== undefined) { | |
| for (var i in entries) { | |
| var entry = entries[i]; | |
| if (entry !== null) { | |
| var id = entry.id.replace("file", ""); | |
| if (api.photoNames[id] !== undefined) { | |
| entry.photoName = api.photoNames[id] | |
| } | |
| if (api.toRemove.indexOf(entry.id) == -1) { | |
| if (entry.name.length > 50) { | |
| entry.name = entry.name.substr(0, 50) + "..." | |
| } | |
| entry.name = '<span id="' + i + '">' + entry.name + "</span>"; | |
| entry.progress = "<div style='height:5px;width:100px;background-color:#ccc;'></div>"; | |
| entry.remove = '<a class="remove" id="r-' + i + '"> </a>'; | |
| entry.size = Math.round(entry.size / 1000); | |
| api.sizeTotal += entry.size; | |
| dataArray.unshift(entry) | |
| } | |
| } | |
| } | |
| api.fileCount = dataArray.length; | |
| for (var j = 0; j < dataArray.length; j++) { | |
| fileIdHash[dataArray[j].id] = j; | |
| dataArray[j].title = dataArray[j].name | |
| } | |
| } | |
| var myColumnDefs = [{ | |
| key: "name", | |
| label: photoLabel, | |
| sortable: false | |
| }, { | |
| key: "title", | |
| label: photoNameLabel, | |
| sortable: false, | |
| formatter: "formattedTitle" | |
| }, { | |
| key: "size", | |
| label: sizeLabel, | |
| sortable: false, | |
| formatter: "formattedSize" | |
| }, { | |
| key: "remove", | |
| label: removeLabel, | |
| sortable: false | |
| }]; | |
| myDataSource = new YAHOO.util.DataSource(dataArray); | |
| myDataSource.responseType = YAHOO.util.DataSource.TYPE_JSARRAY; | |
| myDataSource.responseSchema = { | |
| fields: [{ | |
| key: "id" | |
| }, { | |
| key: "name" | |
| }, { | |
| key: "created" | |
| }, { | |
| key: "modified" | |
| }, { | |
| key: "type" | |
| }, { | |
| key: "size" | |
| }, { | |
| key: "title" | |
| }, { | |
| key: "progress" | |
| }, { | |
| key: "photoName" | |
| }, { | |
| key: "remove" | |
| }] | |
| }; | |
| selectDataTable = new YAHOO.widget.DataTable("add-photos-table", myColumnDefs, myDataSource, { | |
| caption: null, | |
| selectionMode: "single" | |
| }); | |
| var table = $D.get("add-photos-table") | |
| .childNodes[1]; | |
| var footer = table.createTFoot(); | |
| var footerRow = footer.insertRow(0); | |
| var fileCountCell = footerRow.insertCell(0); | |
| fileCountCell.setAttribute("id", "file-count"); | |
| if ((api.fileCount > 1) || (api.fileCount === 0)) { | |
| fileCountCell.innerHTML = api.fileCount + " " + filesLabel | |
| } else { | |
| fileCountCell.innerHTML = api.fileCount + " " + fileLabel | |
| } | |
| var emptyCell1 = footerRow.insertCell(1); | |
| emptyCell1.innerHTML = " "; | |
| var sizeTotal = footerRow.insertCell(2); | |
| sizeTotal.setAttribute("id", "size-total"); | |
| sizeTotal.innerHTML = api.addCommas(api.sizeTotal) + " " + kbLabel; | |
| var emptyCell2 = footerRow.insertCell(3); | |
| emptyCell2.innerHTML = " "; | |
| api.dataTableId = selectDataTable.getId() | |
| }, | |
| handleContentReady: function () { | |
| api.uploader.setAllowMultipleFiles(true); | |
| var ff = new Array({ | |
| description: "Images", | |
| extensions: "*.bmp;*.gif;*.jpeg;*.jpg;*.png" | |
| }); | |
| api.uploader.setFileFilters(ff); | |
| api.createDataTable(); | |
| $D.setStyle("select-block", "visibility", "visible") | |
| }, | |
| onError: function (e) { | |
| var type = e.type; | |
| var rowNum = fileIdHash[e.id]; | |
| var rowId = selectDataTable.getRecord(rowNum) | |
| .getId(); | |
| var photoName = ""; | |
| if ($D.get(rowId) | |
| .childNodes[1].firstChild.firstChild !== null) { | |
| photoName = $D.get(rowId) | |
| .childNodes[1].firstChild.firstChild.value | |
| } | |
| $D.setStyle($D.get(rowId) | |
| .childNodes[1].firstChild, "text-align", "left"); | |
| $D.get(rowId) | |
| .childNodes[1].firstChild.innerHTML = photoName; | |
| var title = e.data; | |
| if (e.data === undefined) { | |
| title = "" | |
| } | |
| if (type == "uploadCompleteData") { | |
| title = e.data | |
| } else { | |
| if (type == "uploadError") { | |
| title = e.status.replace(/"/gi, "") | |
| } | |
| } | |
| api.errors.push(e.id); | |
| var errorIcon = '<img src="' + iconError + '" alt="' + title + '" title="' + title + '"/>'; | |
| $D.get(rowId) | |
| .lastChild.firstChild.innerHTML = errorIcon | |
| }, | |
| onFileSelect: function (e) { | |
| api.tickets = []; | |
| var tempFileCount = 0; | |
| for (var file in e.fileList) { | |
| if (YAHOO.lang.hasOwnProperty(e.fileList, file)) { | |
| var fileID = e.fileList[file].id; | |
| if (api.tickets.indexOf(fileID) == -1) { | |
| if (e.fileList[file].size > uploadFileSizeLimit) { | |
| $D.get("file-limit-error") | |
| .style.display = "block"; | |
| api.toRemove.push(file) | |
| } else { | |
| if (tempFileCount < api.limit) { | |
| api.tickets.push(fileID); | |
| tempFileCount++ | |
| } else { | |
| api.toRemove.push(file); | |
| $D.get("limit-error") | |
| .style.display = "block" | |
| } | |
| } | |
| } | |
| var id = fileID.replace("file", ""); | |
| if ($D.get("title" + id)) { | |
| api.photoNames[id] = $D.get("title" + id) | |
| .value | |
| } | |
| } | |
| } | |
| api.fileList = e.fileList; | |
| api.createDataTable(api.fileList); | |
| $D.get("upload-button-wrapper") | |
| .style.height = "25px"; | |
| $D.get("upload-button-wrapper") | |
| .style.visibility = "visible"; | |
| $E.on($D.get("add-photos-table"), "click", api.onRemove) | |
| }, | |
| onRemove: function (e) { | |
| var targetID = $E.getTarget(e) | |
| .id; | |
| if (targetID.indexOf("r-") > -1) { | |
| var fileID = targetID.substring(2); | |
| var rowID = $E.getTarget(e) | |
| .parentNode; | |
| var recordNode = rowID.parentNode.parentNode; | |
| var recordID = recordNode.id; | |
| $D.setStyle(recordID, "display", "none"); | |
| var deletedRowClass = $D.get(recordID) | |
| .getAttribute("class"); | |
| var lastRecordID = $D.getLastChild(recordNode.parentNode) | |
| .id; | |
| api.zebraTable(deletedRowClass, recordID, lastRecordID); | |
| api.updateFileCount(false); | |
| api.updateSizeTotal(fileID, false); | |
| api.tickets.splice(api.tickets.indexOf(fileID), 1); | |
| $E.preventDefault(e) | |
| } | |
| if (api.fileCount === 0) { | |
| api.uploader.clearFileList() | |
| } | |
| }, | |
| onUploadComplete: function (e) { | |
| var rowNum = fileIdHash[e.id]; | |
| var rowId = selectDataTable.getRecord(rowNum) | |
| .getId(); | |
| $D.get(rowId) | |
| .lastChild.firstChild.innerHTML = api.completed; | |
| if (api.tickets.length > 0) { | |
| api.upload(0, 0) | |
| } | |
| }, | |
| onUploadError: function (e) { | |
| api.onError(e); | |
| if (api.successful > 0) { | |
| api.successful-- | |
| } | |
| if (api.tickets.length > 0) { | |
| api.upload(0, 0) | |
| } else { | |
| if (api.tickets.length === 0) { | |
| api.uploadDone() | |
| } | |
| } | |
| }, | |
| onUploadProgress: function (e) { | |
| var progress = Math.round(100 * (e.bytesLoaded / e.bytesTotal)); | |
| var progressBar = '<div style="height:5px;width:100px;background-color:#ccc;"><div style="height:5px;background-color:#f00;width:' + progress + 'px;"></div></div>'; | |
| var rowNum = fileIdHash[e.id]; | |
| var rowId = selectDataTable.getRecord(rowNum) | |
| .getId(); | |
| $D.get(rowId) | |
| .lastChild.firstChild.innerHTML = progressBar | |
| }, | |
| onUploadResponse: function (e) { | |
| if (e.data.toUpperCase() | |
| .indexOf("ERROR") > -1) { | |
| api.onError(e) | |
| } else { | |
| api.successful++ | |
| } | |
| if (api.tickets.length === 0) { | |
| api.uploadDone() | |
| } | |
| }, | |
| onUploadStart: function (e) { | |
| var rowNum = fileIdHash[e.id]; | |
| var rowId = selectDataTable.getRecord(rowNum) | |
| .getId(); | |
| var photoName = $D.get(rowId) | |
| .childNodes[1].firstChild.firstChild.value; | |
| $D.setStyle($D.get(rowId) | |
| .childNodes[1].firstChild, "text-align", "left"); | |
| $D.get(rowId) | |
| .childNodes[1].firstChild.innerHTML = photoName; | |
| if (api.state == "initial") { | |
| $D.get("select-button") | |
| .setAttribute("disabled", "disabled"); | |
| $D.setStyle("select-files", "display", "none"); | |
| $D.get("upload-button") | |
| .setAttribute("disabled", "disabled"); | |
| $D.get("upload-button") | |
| .style.backgroundColor = "#cfcfcf"; | |
| $D.get("upload-button") | |
| .value = uploadingLabel; | |
| $D.get(api.dataTableId + "-th-remove") | |
| .firstChild.firstChild.innerHTML = uploadingProgressLabel; | |
| var emptyProgress = "<div style='height:5px;width:100px;background-color:#ccc;'><div style='height:5px;background-color:#f00;width:0px;'></div></div>"; | |
| for (var j = 0; j < dataArray.length; j++) { | |
| rowNum = fileIdHash[dataArray[j].id]; | |
| rowId = selectDataTable.getRecord(rowNum) | |
| .getId(); | |
| $D.get(rowId) | |
| .lastChild.firstChild.innerHTML = emptyProgress | |
| } | |
| api.state = "uploading" | |
| } | |
| }, | |
| retryUpload: function (e) { | |
| if (api.state != "retry") { | |
| $D.setStyle("retry-msg", "visibility", "hidden"); | |
| $D.setStyle("complete-msg", "height", "0px"); | |
| $D.setStyle("complete-msg", "visibility", "hidden"); | |
| $D.setStyle("upload-button-wrapper", "height", "25px"); | |
| $D.setStyle("upload-button-wrapper", "visibility", "visible"); | |
| $D.setStyle("select-block", "visibility", "visible"); | |
| api.createDataTable(); | |
| var newFileList = []; | |
| for (var i in api.fileList) { | |
| if (api.fileList[i]) { | |
| fileID = api.fileList[i].id; | |
| if (api.errors.indexOf(fileID) > -1) { | |
| newFileList[i] = api.fileList[i] | |
| } else { | |
| api.fileList[i] = null; | |
| api.uploader.removeFile(fileID) | |
| } | |
| } | |
| } | |
| for (var j in api.errors) { | |
| fileID = api.errors[j]; | |
| if (newFileList[fileID]) { | |
| newFileList[fileID].name = newFileList[fileID].name.replace('<span id="' + newFileList[fileID].id + '">', ""); | |
| newFileList[fileID].name = newFileList[fileID].name.replace("</span>", ""); | |
| newFileList[fileID].size = newFileList[fileID].size * 1000; | |
| api.fileList[fileID] = newFileList[fileID] | |
| } | |
| } | |
| api.createDataTable(api.fileList); | |
| api.tickets = api.errors; | |
| api.errors = []; | |
| api.vitalityCheck(e); | |
| api.state = "retry" | |
| } | |
| }, | |
| singleUpload: function (showVitalityDialog, vitalityOn) { | |
| var fileID = api.tickets[0]; | |
| if (fileID !== null) { | |
| var photoName = $D.get("title" + fileID.replace("file", "")); | |
| if (photoName === null) { | |
| photoName = "" | |
| } else { | |
| photoName = photoName.value | |
| } | |
| var done = ""; | |
| if (api.tickets.length == 1) { | |
| done = 1 | |
| } | |
| api.uploader.upload(fileID, uploadHost + "/group/" + groupName + "/photos/album/" + containerId + "/pic/receive?app=" + domainName + "&refId=" + referenceId + nextView, "POST", { | |
| phototitle: photoName, | |
| realCookie: document.cookie, | |
| done: done, | |
| successful: api.successful, | |
| showVitalityDialog: 0, | |
| vitalityOn: 0 | |
| }); | |
| api.tickets.splice(api.tickets.indexOf(fileID), 1) | |
| } | |
| }, | |
| sizeFormatter: function (elCell, oRecord, oColumn, oData) { | |
| var size = oRecord.getData("size"); | |
| size = api.addCommas(size); | |
| elCell.innerHTML = '<span class="file-size">' + size + " " + kbLabel + "</span>" | |
| }, | |
| titleFormatter: function (elCell, oRecord, oColumn, oData) { | |
| var titleID = oRecord.getData("id") | |
| .replace("file", ""); | |
| var photoName = ""; | |
| if (oRecord.getData("photoName") !== null) { | |
| if (oRecord.getData("photoName") | |
| .length > 0) { | |
| photoName = oRecord.getData("photoName") | |
| } | |
| } | |
| elCell.innerHTML = '<input type="text" name="title' + titleID + '" value="' + photoName + '" maxlength="40" id="title' + titleID + '"/>' | |
| }, | |
| upload: function (showVitalityDialog, vitalityOn) { | |
| if (api.fileCount <= api.limit) { | |
| api.singleUpload(0, 0) | |
| } else { | |
| $D.get("limit-error") | |
| .style.display = "block" | |
| } | |
| }, | |
| updateFileCount: function (isRetry) { | |
| if (!isRetry) { | |
| if (api.fileCount > 0) { | |
| api.fileCount-- | |
| } | |
| } else { | |
| api.fileCount = api.errors.length | |
| } | |
| if ((api.fileCount > 1) || (api.fileCount === 0)) { | |
| $D.get("file-count") | |
| .innerHTML = api.fileCount + " " + filesLabel | |
| } else { | |
| $D.get("file-count") | |
| .innerHTML = api.fileCount + " " + fileLabel | |
| } | |
| }, | |
| updateSizeTotal: function (fileID, isRetry) { | |
| if (!isRetry) { | |
| if (api.sizeTotal > 0) { | |
| api.sizeTotal -= api.fileList[fileID].size | |
| } | |
| } else { | |
| api.sizeTotal = 0; | |
| for (var i = 0; i < api.errors.length; i++) { | |
| fileID = api.errors[i]; | |
| row = $D.get(fileID) | |
| .parentNode.parentNode.parentNode; | |
| size = parseInt(row.childNodes[2].firstChild.firstChild.innerHTML.replace(" KB", ""), 10); | |
| api.sizeTotal += size | |
| } | |
| } | |
| if (api.fileCount === 0) { | |
| $D.get("size-total") | |
| .innerHTML = "0 " + kbLabel | |
| } else { | |
| api.uploader.removeFile(fileID); | |
| $D.get("size-total") | |
| .innerHTML = api.addCommas(api.sizeTotal) + " " + kbLabel | |
| } | |
| }, | |
| uploadDone: function () { | |
| api.state = "complete"; | |
| $D.setStyle("upload-button-wrapper", "height", "0px"); | |
| $D.setStyle("upload-button-wrapper", "visibility", "hidden"); | |
| $D.setStyle("complete-msg", "height", "25px"); | |
| $D.setStyle("complete-msg", "visibility", "visible"); | |
| if (api.errors.length > 0) { | |
| if ($E.getListeners("retry-button", "click") === null) { | |
| $E.on("retry-button", "click", api.retryUpload, api, true) | |
| } | |
| $D.setStyle("retry-msg", "visibility", "visible") | |
| } | |
| }, | |
| vitalityCheck: function (e) { | |
| if (0) { | |
| YAHOO.Groups.lib.dialogs.VitalityDialog(groupName, function (vitalityOn, dontRemindMe) { | |
| api.vitalityOn = 0; | |
| api.upload(0, 0) | |
| }); | |
| $E.onAvailable("dynamic_dialog_div", $E.on("dialog_transparent_div", "click", function () { | |
| $D.setStyle("dialog_transparent_div", "display", "none"); | |
| $D.setStyle("dynamic_dialog_div", "display", "none"); | |
| api.upload(false, 0) | |
| })); | |
| YAHOO.Groups.oCurrentDialog.init("ok_cancel_dialog_ok_anchor", "ok_cancel_dialog_cancel_anchor"); | |
| $E.stopEvent(e) | |
| } else { | |
| api.upload(0, 0) | |
| } | |
| }, | |
| getZebraRowColor: function (recordID, oldRowClass, newRowClass) { | |
| $D.replaceClass(recordID, oldRowClass, newRowClass); | |
| api.lastRowClass = newRowClass; | |
| if (newRowClass.indexOf("even") > -1) { | |
| newRowClass = "yui-dt-odd" | |
| } else { | |
| newRowClass = "yui-dt-even" | |
| } | |
| return newRowClass | |
| }, | |
| zebraTable: function (newRowClass, recordID, lastRecordID) { | |
| while (recordID != lastRecordID) { | |
| var oldRowClass = $D.get(recordID) | |
| .getAttribute("class"); | |
| if ($D.getStyle(recordID, "display") != "none") { | |
| newRowClass = api.getZebraRowColor(recordID, oldRowClass, newRowClass) | |
| } | |
| recordID = $D.getNextSibling(recordID) | |
| .id | |
| } | |
| newRowClass = newRowClass.substring(newRowClass.indexOf(" ") + 1); | |
| oldRowClass = $D.get(recordID) | |
| .getAttribute("class"); | |
| var fileID = recordID; | |
| if (recordID.indexOf("file") > -1) { | |
| recordID = $D.get(recordID) | |
| .parentNode.parentNode.parentNode.id; | |
| oldRowClass = $D.get(recordID) | |
| .getAttribute("class"); | |
| oldRowClass = oldRowClass.substring(oldRowClass.indexOf(" ") + 1) | |
| } | |
| if (fileID == lastRecordID) { | |
| newRowClass = api.getZebraRowColor(recordID, oldRowClass, newRowClass) | |
| } | |
| }, | |
| init: function () { | |
| var uiLayer = $D.getRegion("select-button"); | |
| var overlay = $D.get("uploader-overlay"); | |
| $D.setStyle(overlay, "width", uiLayer.right - uiLayer.left + "px"); | |
| $D.setStyle(overlay, "height", uiLayer.bottom - uiLayer.top + "px"); | |
| YAHOO.widget.Uploader.SWFURL = photosSwf + "/" + version + "/swf/uploader.swf"; | |
| api.uploader = new YAHOO.widget.Uploader("uploader-overlay"); | |
| if ($D.get("uploader-overlay") | |
| .innerHTML.length === 0) { | |
| $D.get("select-files") | |
| .innerHTML = flashRequired | |
| } | |
| api.uploader.addListener("contentReady", api.handleContentReady, api, true); | |
| api.uploader.addListener("fileSelect", api.onFileSelect, api, true); | |
| api.uploader.addListener("uploadStart", api.onUploadStart, api, true); | |
| api.uploader.addListener("uploadProgress", api.onUploadProgress, api, true); | |
| api.uploader.addListener("uploadComplete", api.onUploadComplete, api, true); | |
| api.uploader.addListener("uploadCompleteData", api.onUploadResponse, api, true); | |
| api.uploader.addListener("uploadError", api.onUploadError, api, true); | |
| $D.setStyle("select-block", "visibility", "visible"); | |
| $E.on("upload-button", "click", api.vitalityCheck, api, true); | |
| YAHOO.widget.DataTable.Formatter.formattedSize = api.sizeFormatter; | |
| YAHOO.widget.DataTable.Formatter.formattedTitle = api.titleFormatter | |
| } | |
| }; | |
| if (!Array.indexOf) { | |
| Array.prototype.indexOf = function (obj) { | |
| for (var i = 0; i < this.length; i++) { | |
| if (this[i] == obj) { | |
| return i | |
| } | |
| } | |
| return -1 | |
| } | |
| } | |
| $E.onDOMReady(api.init); | |
| return api | |
| }; |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment