X-Git-Url: http://git.ithinksw.org/extjs.git/blobdiff_plain/ee06f37b0f6f6d94cd05a6ffae556660f7c4a2bc..c930e9176a5a85509c5b0230e2bff5c22a591432:/docs/source/ext-base.html?ds=sidebyside diff --git a/docs/source/ext-base.html b/docs/source/ext-base.html new file mode 100644 index 00000000..67f66bb9 --- /dev/null +++ b/docs/source/ext-base.html @@ -0,0 +1,2741 @@ + +
+/* + * Ext JS Library 2.0.1 + * Copyright(c) 2006-2008, Ext JS, LLC. + * licensing@extjs.com + * + * http://extjs.com/license + */ + + +Ext = {version: '2.0.1'}; + + +window["undefined"] = window["undefined"]; + + + + +Ext.apply = function(o, c, defaults){ + if(defaults){ + + Ext.apply(o, defaults); + } + if(o && c && typeof c == 'object'){ + for(var p in c){ + o[p] = c[p]; + } + } + return o; +}; + +(function(){ + var idSeed = 0; + var ua = navigator.userAgent.toLowerCase(); + + var isStrict = document.compatMode == "CSS1Compat", + isOpera = ua.indexOf("opera") > -1, + isSafari = (/webkit|khtml/).test(ua), + isSafari3 = isSafari && ua.indexOf('webkit/5') != -1, + isIE = !isOpera && ua.indexOf("msie") > -1, + isIE7 = !isOpera && ua.indexOf("msie 7") > -1, + isGecko = !isSafari && ua.indexOf("gecko") > -1, + isBorderBox = isIE && !isStrict, + isWindows = (ua.indexOf("windows") != -1 || ua.indexOf("win32") != -1), + isMac = (ua.indexOf("macintosh") != -1 || ua.indexOf("mac os x") != -1), + isAir = (ua.indexOf("adobeair") != -1), + isLinux = (ua.indexOf("linux") != -1), + isSecure = window.location.href.toLowerCase().indexOf("https") === 0; + + + if(isIE && !isIE7){ + try{ + document.execCommand("BackgroundImageCache", false, true); + }catch(e){} + } + + Ext.apply(Ext, { + + isStrict : isStrict, + + isSecure : isSecure, + + isReady : false, + + + enableGarbageCollector : true, + + + enableListenerCollection:false, + + + + SSL_SECURE_URL : "javascript:false", + + + BLANK_IMAGE_URL : "http:/"+"/extjs.com/s.gif", + + + emptyFn : function(){}, + + + applyIf : function(o, c){ + if(o && c){ + for(var p in c){ + if(typeof o[p] == "undefined"){ o[p] = c[p]; } + } + } + return o; + }, + + + addBehaviors : function(o){ + if(!Ext.isReady){ + Ext.onReady(function(){ + Ext.addBehaviors(o); + }); + return; + } + var cache = {}; + for(var b in o){ + var parts = b.split('@'); + if(parts[1]){ + var s = parts[0]; + if(!cache[s]){ + cache[s] = Ext.select(s); + } + cache[s].on(parts[1], o[b]); + } + } + cache = null; + }, + + + id : function(el, prefix){ + prefix = prefix || "ext-gen"; + el = Ext.getDom(el); + var id = prefix + (++idSeed); + return el ? (el.id ? el.id : (el.id = id)) : id; + }, + + + extend : function(){ + + var io = function(o){ + for(var m in o){ + this[m] = o[m]; + } + }; + var oc = Object.prototype.constructor; + + return function(sb, sp, overrides){ + if(typeof sp == 'object'){ + overrides = sp; + sp = sb; + sb = overrides.constructor != oc ? overrides.constructor : function(){sp.apply(this, arguments);}; + } + var F = function(){}, sbp, spp = sp.prototype; + F.prototype = spp; + sbp = sb.prototype = new F(); + sbp.constructor=sb; + sb.superclass=spp; + if(spp.constructor == oc){ + spp.constructor=sp; + } + sb.override = function(o){ + Ext.override(sb, o); + }; + sbp.override = io; + Ext.override(sb, overrides); + return sb; + }; + }(), + + + override : function(origclass, overrides){ + if(overrides){ + var p = origclass.prototype; + for(var method in overrides){ + p[method] = overrides[method]; + } + } + }, + + + namespace : function(){ + var a=arguments, o=null, i, j, d, rt; + for (i=0; i+ + \ No newline at end of file= 0) { + cacheItem = listeners[index]; + } + + if (!el || !cacheItem) { + return false; + } + + this.doRemove(el, eventName, cacheItem[this.WFN], false); + + delete listeners[index][this.WFN]; + delete listeners[index][this.FN]; + listeners.splice(index, 1); + + return true; + + }, + + + getTarget: function(ev, resolveTextNode) { + ev = ev.browserEvent || ev; + var t = ev.target || ev.srcElement; + return this.resolveTextNode(t); + }, + + + resolveTextNode: function(node) { + if (Ext.isSafari && node && 3 == node.nodeType) { + return node.parentNode; + } else { + return node; + } + }, + + + getPageX: function(ev) { + ev = ev.browserEvent || ev; + var x = ev.pageX; + if (!x && 0 !== x) { + x = ev.clientX || 0; + + if (Ext.isIE) { + x += this.getScroll()[1]; + } + } + + return x; + }, + + + getPageY: function(ev) { + ev = ev.browserEvent || ev; + var y = ev.pageY; + if (!y && 0 !== y) { + y = ev.clientY || 0; + + if (Ext.isIE) { + y += this.getScroll()[0]; + } + } + + + return y; + }, + + + getXY: function(ev) { + ev = ev.browserEvent || ev; + return [this.getPageX(ev), this.getPageY(ev)]; + }, + + + getRelatedTarget: function(ev) { + ev = ev.browserEvent || ev; + var t = ev.relatedTarget; + if (!t) { + if (ev.type == "mouseout") { + t = ev.toElement; + } else if (ev.type == "mouseover") { + t = ev.fromElement; + } + } + + return this.resolveTextNode(t); + }, + + + getTime: function(ev) { + ev = ev.browserEvent || ev; + if (!ev.time) { + var t = new Date().getTime(); + try { + ev.time = t; + } catch(ex) { + this.lastError = ex; + return t; + } + } + + return ev.time; + }, + + + stopEvent: function(ev) { + this.stopPropagation(ev); + this.preventDefault(ev); + }, + + + stopPropagation: function(ev) { + ev = ev.browserEvent || ev; + if (ev.stopPropagation) { + ev.stopPropagation(); + } else { + ev.cancelBubble = true; + } + }, + + + preventDefault: function(ev) { + ev = ev.browserEvent || ev; + if(ev.preventDefault) { + ev.preventDefault(); + } else { + ev.returnValue = false; + } + }, + + + getEvent: function(e) { + var ev = e || window.event; + if (!ev) { + var c = this.getEvent.caller; + while (c) { + ev = c.arguments[0]; + if (ev && Event == ev.constructor) { + break; + } + c = c.caller; + } + } + return ev; + }, + + + getCharCode: function(ev) { + ev = ev.browserEvent || ev; + return ev.charCode || ev.keyCode || 0; + }, + + + _getCacheIndex: function(el, eventName, fn) { + for (var i = 0,len = listeners.length; i < len; ++i) { + var li = listeners[i]; + if (li && + li[this.FN] == fn && + li[this.EL] == el && + li[this.TYPE] == eventName) { + return i; + } + } + + return -1; + }, + + + elCache: {}, + + + getEl: function(id) { + return document.getElementById(id); + }, + + + clearCache: function() { + }, + + + _load: function(e) { + loadComplete = true; + var EU = Ext.lib.Event; + + + if (Ext.isIE) { + EU.doRemove(window, "load", EU._load); + } + }, + + + _tryPreloadAttach: function() { + + if (this.locked) { + return false; + } + + this.locked = true; + + + var tryAgain = !loadComplete; + if (!tryAgain) { + tryAgain = (retryCount > 0); + } + + + var notAvail = []; + for (var i = 0,len = onAvailStack.length; i < len; ++i) { + var item = onAvailStack[i]; + if (item) { + var el = this.getEl(item.id); + + if (el) { + if (!item.checkReady || + loadComplete || + el.nextSibling || + (document && document.body)) { + + var scope = el; + if (item.override) { + if (item.override === true) { + scope = item.obj; + } else { + scope = item.override; + } + } + item.fn.call(scope, item.obj); + onAvailStack[i] = null; + } + } else { + notAvail.push(item); + } + } + } + + retryCount = (notAvail.length === 0) ? 0 : retryCount - 1; + + if (tryAgain) { + + this.startInterval(); + } else { + clearInterval(this._interval); + this._interval = null; + } + + this.locked = false; + + return true; + + }, + + + purgeElement: function(el, recurse, eventName) { + var elListeners = this.getListeners(el, eventName); + if (elListeners) { + for (var i = 0,len = elListeners.length; i < len; ++i) { + var l = elListeners[i]; + this.removeListener(el, l.type, l.fn); + } + } + + if (recurse && el && el.childNodes) { + for (i = 0,len = el.childNodes.length; i < len; ++i) { + this.purgeElement(el.childNodes[i], recurse, eventName); + } + } + }, + + + getListeners: function(el, eventName) { + var results = [], searchLists; + if (!eventName) { + searchLists = [listeners, unloadListeners]; + } else if (eventName == "unload") { + searchLists = [unloadListeners]; + } else { + searchLists = [listeners]; + } + + for (var j = 0; j < searchLists.length; ++j) { + var searchList = searchLists[j]; + if (searchList && searchList.length > 0) { + for (var i = 0,len = searchList.length; i < len; ++i) { + var l = searchList[i]; + if (l && l[this.EL] === el && + (!eventName || eventName === l[this.TYPE])) { + results.push({ + type: l[this.TYPE], + fn: l[this.FN], + obj: l[this.OBJ], + adjust: l[this.ADJ_SCOPE], + index: i + }); + } + } + } + } + + return (results.length) ? results : null; + }, + + + _unload: function(e) { + + var EU = Ext.lib.Event, i, j, l, len, index; + + for (i = 0,len = unloadListeners.length; i < len; ++i) { + l = unloadListeners[i]; + if (l) { + var scope = window; + if (l[EU.ADJ_SCOPE]) { + if (l[EU.ADJ_SCOPE] === true) { + scope = l[EU.OBJ]; + } else { + scope = l[EU.ADJ_SCOPE]; + } + } + l[EU.FN].call(scope, EU.getEvent(e), l[EU.OBJ]); + unloadListeners[i] = null; + l = null; + scope = null; + } + } + + unloadListeners = null; + + if (listeners && listeners.length > 0) { + j = listeners.length; + while (j) { + index = j - 1; + l = listeners[index]; + if (l) { + EU.removeListener(l[EU.EL], l[EU.TYPE], + l[EU.FN], index); + } + j = j - 1; + } + l = null; + + EU.clearCache(); + } + + EU.doRemove(window, "unload", EU._unload); + + }, + + + getScroll: function() { + var dd = document.documentElement, db = document.body; + if (dd && (dd.scrollTop || dd.scrollLeft)) { + return [dd.scrollTop, dd.scrollLeft]; + } else if (db) { + return [db.scrollTop, db.scrollLeft]; + } else { + return [0, 0]; + } + }, + + + doAdd: function () { + if (window.addEventListener) { + return function(el, eventName, fn, capture) { + el.addEventListener(eventName, fn, (capture)); + }; + } else if (window.attachEvent) { + return function(el, eventName, fn, capture) { + el.attachEvent("on" + eventName, fn); + }; + } else { + return function() { + }; + } + }(), + + + doRemove: function() { + if (window.removeEventListener) { + return function (el, eventName, fn, capture) { + el.removeEventListener(eventName, fn, (capture)); + }; + } else if (window.detachEvent) { + return function (el, eventName, fn) { + el.detachEvent("on" + eventName, fn); + }; + } else { + return function() { + }; + } + }() + }; + + }(); + + var E = Ext.lib.Event; + E.on = E.addListener; + E.un = E.removeListener; + if (document && document.body) { + E._load(); + } else { + E.doAdd(window, "load", E._load); + } + E.doAdd(window, "unload", E._unload); + E._tryPreloadAttach(); + + Ext.lib.Ajax = { + request : function(method, uri, cb, data, options) { + if(options){ + var hs = options.headers; + if(hs){ + for(var h in hs){ + if(hs.hasOwnProperty(h)){ + this.initHeader(h, hs[h], false); + } + } + } + if(options.xmlData){ + this.initHeader('Content-Type', 'text/xml', false); + method = 'POST'; + data = options.xmlData; + }else if(options.jsonData){ + this.initHeader('Content-Type', 'text/javascript', false); + method = 'POST'; + data = typeof options.jsonData == 'object' ? Ext.encode(options.jsonData) : options.jsonData; + } + } + + return this.asyncRequest(method, uri, cb, data); + }, + + serializeForm : function(form) { + if(typeof form == 'string') { + form = (document.getElementById(form) || document.forms[form]); + } + + var el, name, val, disabled, data = '', hasSubmit = false; + for (var i = 0; i < form.elements.length; i++) { + el = form.elements[i]; + disabled = form.elements[i].disabled; + name = form.elements[i].name; + val = form.elements[i].value; + + if (!disabled && name){ + switch (el.type) + { + case 'select-one': + case 'select-multiple': + for (var j = 0; j < el.options.length; j++) { + if (el.options[j].selected) { + if (Ext.isIE) { + data += encodeURIComponent(name) + '=' + encodeURIComponent(el.options[j].attributes['value'].specified ? el.options[j].value : el.options[j].text) + '&'; + } + else { + data += encodeURIComponent(name) + '=' + encodeURIComponent(el.options[j].hasAttribute('value') ? el.options[j].value : el.options[j].text) + '&'; + } + } + } + break; + case 'radio': + case 'checkbox': + if (el.checked) { + data += encodeURIComponent(name) + '=' + encodeURIComponent(val) + '&'; + } + break; + case 'file': + + case undefined: + + case 'reset': + + case 'button': + + break; + case 'submit': + if(hasSubmit == false) { + data += encodeURIComponent(name) + '=' + encodeURIComponent(val) + '&'; + hasSubmit = true; + } + break; + default: + data += encodeURIComponent(name) + '=' + encodeURIComponent(val) + '&'; + break; + } + } + } + data = data.substr(0, data.length - 1); + return data; + }, + + headers:{}, + + hasHeaders:false, + + useDefaultHeader:true, + + defaultPostHeader:'application/x-www-form-urlencoded', + + useDefaultXhrHeader:true, + + defaultXhrHeader:'XMLHttpRequest', + + hasDefaultHeaders:true, + + defaultHeaders:{}, + + poll:{}, + + timeout:{}, + + pollInterval:50, + + transactionId:0, + + setProgId:function(id) + { + this.activeX.unshift(id); + }, + + setDefaultPostHeader:function(b) + { + this.useDefaultHeader = b; + }, + + setDefaultXhrHeader:function(b) + { + this.useDefaultXhrHeader = b; + }, + + setPollingInterval:function(i) + { + if (typeof i == 'number' && isFinite(i)) { + this.pollInterval = i; + } + }, + + createXhrObject:function(transactionId) + { + var obj,http; + try + { + + http = new XMLHttpRequest(); + + obj = { conn:http, tId:transactionId }; + } + catch(e) + { + for (var i = 0; i < this.activeX.length; ++i) { + try + { + + http = new ActiveXObject(this.activeX[i]); + + obj = { conn:http, tId:transactionId }; + break; + } + catch(e) { + } + } + } + finally + { + return obj; + } + }, + + getConnectionObject:function() + { + var o; + var tId = this.transactionId; + + try + { + o = this.createXhrObject(tId); + if (o) { + this.transactionId++; + } + } + catch(e) { + } + finally + { + return o; + } + }, + + asyncRequest:function(method, uri, callback, postData) + { + var o = this.getConnectionObject(); + + if (!o) { + return null; + } + else { + o.conn.open(method, uri, true); + + if (this.useDefaultXhrHeader) { + if (!this.defaultHeaders['X-Requested-With']) { + this.initHeader('X-Requested-With', this.defaultXhrHeader, true); + } + } + + if(postData && this.useDefaultHeader){ + this.initHeader('Content-Type', this.defaultPostHeader); + } + + if (this.hasDefaultHeaders || this.hasHeaders) { + this.setHeader(o); + } + + this.handleReadyState(o, callback); + o.conn.send(postData || null); + + return o; + } + }, + + handleReadyState:function(o, callback) + { + var oConn = this; + + if (callback && callback.timeout) { + this.timeout[o.tId] = window.setTimeout(function() { + oConn.abort(o, callback, true); + }, callback.timeout); + } + + this.poll[o.tId] = window.setInterval( + function() { + if (o.conn && o.conn.readyState == 4) { + window.clearInterval(oConn.poll[o.tId]); + delete oConn.poll[o.tId]; + + if (callback && callback.timeout) { + window.clearTimeout(oConn.timeout[o.tId]); + delete oConn.timeout[o.tId]; + } + + oConn.handleTransactionResponse(o, callback); + } + } + , this.pollInterval); + }, + + handleTransactionResponse:function(o, callback, isAbort) + { + + if (!callback) { + this.releaseObject(o); + return; + } + + var httpStatus, responseObject; + + try + { + if (o.conn.status !== undefined && o.conn.status != 0) { + httpStatus = o.conn.status; + } + else { + httpStatus = 13030; + } + } + catch(e) { + + + httpStatus = 13030; + } + + if (httpStatus >= 200 && httpStatus < 300) { + responseObject = this.createResponseObject(o, callback.argument); + if (callback.success) { + if (!callback.scope) { + callback.success(responseObject); + } + else { + + + callback.success.apply(callback.scope, [responseObject]); + } + } + } + else { + switch (httpStatus) { + + case 12002: + case 12029: + case 12030: + case 12031: + case 12152: + case 13030: + responseObject = this.createExceptionObject(o.tId, callback.argument, (isAbort ? isAbort : false)); + if (callback.failure) { + if (!callback.scope) { + callback.failure(responseObject); + } + else { + callback.failure.apply(callback.scope, [responseObject]); + } + } + break; + default: + responseObject = this.createResponseObject(o, callback.argument); + if (callback.failure) { + if (!callback.scope) { + callback.failure(responseObject); + } + else { + callback.failure.apply(callback.scope, [responseObject]); + } + } + } + } + + this.releaseObject(o); + responseObject = null; + }, + + createResponseObject:function(o, callbackArg) + { + var obj = {}; + var headerObj = {}; + + try + { + var headerStr = o.conn.getAllResponseHeaders(); + var header = headerStr.split('\n'); + for (var i = 0; i < header.length; i++) { + var delimitPos = header[i].indexOf(':'); + if (delimitPos != -1) { + headerObj[header[i].substring(0, delimitPos)] = header[i].substring(delimitPos + 2); + } + } + } + catch(e) { + } + + obj.tId = o.tId; + obj.status = o.conn.status; + obj.statusText = o.conn.statusText; + obj.getResponseHeader = headerObj; + obj.getAllResponseHeaders = headerStr; + obj.responseText = o.conn.responseText; + obj.responseXML = o.conn.responseXML; + + if (typeof callbackArg !== undefined) { + obj.argument = callbackArg; + } + + return obj; + }, + + createExceptionObject:function(tId, callbackArg, isAbort) + { + var COMM_CODE = 0; + var COMM_ERROR = 'communication failure'; + var ABORT_CODE = -1; + var ABORT_ERROR = 'transaction aborted'; + + var obj = {}; + + obj.tId = tId; + if (isAbort) { + obj.status = ABORT_CODE; + obj.statusText = ABORT_ERROR; + } + else { + obj.status = COMM_CODE; + obj.statusText = COMM_ERROR; + } + + if (callbackArg) { + obj.argument = callbackArg; + } + + return obj; + }, + + initHeader:function(label, value, isDefault) + { + var headerObj = (isDefault) ? this.defaultHeaders : this.headers; + + if (headerObj[label] === undefined) { + headerObj[label] = value; + } + else { + + + headerObj[label] = value + "," + headerObj[label]; + } + + if (isDefault) { + this.hasDefaultHeaders = true; + } + else { + this.hasHeaders = true; + } + }, + + + setHeader:function(o) + { + if (this.hasDefaultHeaders) { + for (var prop in this.defaultHeaders) { + if (this.defaultHeaders.hasOwnProperty(prop)) { + o.conn.setRequestHeader(prop, this.defaultHeaders[prop]); + } + } + } + + if (this.hasHeaders) { + for (var prop in this.headers) { + if (this.headers.hasOwnProperty(prop)) { + o.conn.setRequestHeader(prop, this.headers[prop]); + } + } + this.headers = {}; + this.hasHeaders = false; + } + }, + + resetDefaultHeaders:function() { + delete this.defaultHeaders; + this.defaultHeaders = {}; + this.hasDefaultHeaders = false; + }, + + abort:function(o, callback, isTimeout) + { + if (this.isCallInProgress(o)) { + o.conn.abort(); + window.clearInterval(this.poll[o.tId]); + delete this.poll[o.tId]; + if (isTimeout) { + delete this.timeout[o.tId]; + } + + this.handleTransactionResponse(o, callback, true); + + return true; + } + else { + return false; + } + }, + + + isCallInProgress:function(o) + { + + + if (o.conn) { + return o.conn.readyState != 4 && o.conn.readyState != 0; + } + else { + + return false; + } + }, + + + releaseObject:function(o) + { + + o.conn = null; + + o = null; + }, + + activeX:[ + 'MSXML2.XMLHTTP.3.0', + 'MSXML2.XMLHTTP', + 'Microsoft.XMLHTTP' + ] + + + }; + + + Ext.lib.Region = function(t, r, b, l) { + this.top = t; + this[1] = t; + this.right = r; + this.bottom = b; + this.left = l; + this[0] = l; + }; + + Ext.lib.Region.prototype = { + contains : function(region) { + return ( region.left >= this.left && + region.right <= this.right && + region.top >= this.top && + region.bottom <= this.bottom ); + + }, + + getArea : function() { + return ( (this.bottom - this.top) * (this.right - this.left) ); + }, + + intersect : function(region) { + var t = Math.max(this.top, region.top); + var r = Math.min(this.right, region.right); + var b = Math.min(this.bottom, region.bottom); + var l = Math.max(this.left, region.left); + + if (b >= t && r >= l) { + return new Ext.lib.Region(t, r, b, l); + } else { + return null; + } + }, + union : function(region) { + var t = Math.min(this.top, region.top); + var r = Math.max(this.right, region.right); + var b = Math.max(this.bottom, region.bottom); + var l = Math.min(this.left, region.left); + + return new Ext.lib.Region(t, r, b, l); + }, + + constrainTo : function(r) { + this.top = this.top.constrain(r.top, r.bottom); + this.bottom = this.bottom.constrain(r.top, r.bottom); + this.left = this.left.constrain(r.left, r.right); + this.right = this.right.constrain(r.left, r.right); + return this; + }, + + adjust : function(t, l, b, r) { + this.top += t; + this.left += l; + this.right += r; + this.bottom += b; + return this; + } + }; + + Ext.lib.Region.getRegion = function(el) { + var p = Ext.lib.Dom.getXY(el); + + var t = p[1]; + var r = p[0] + el.offsetWidth; + var b = p[1] + el.offsetHeight; + var l = p[0]; + + return new Ext.lib.Region(t, r, b, l); + }; + + Ext.lib.Point = function(x, y) { + if (Ext.isArray(x)) { + y = x[1]; + x = x[0]; + } + this.x = this.right = this.left = this[0] = x; + this.y = this.top = this.bottom = this[1] = y; + }; + + Ext.lib.Point.prototype = new Ext.lib.Region(); + + + Ext.lib.Anim = { + scroll : function(el, args, duration, easing, cb, scope) { + return this.run(el, args, duration, easing, cb, scope, Ext.lib.Scroll); + }, + + motion : function(el, args, duration, easing, cb, scope) { + return this.run(el, args, duration, easing, cb, scope, Ext.lib.Motion); + }, + + color : function(el, args, duration, easing, cb, scope) { + return this.run(el, args, duration, easing, cb, scope, Ext.lib.ColorAnim); + }, + + run : function(el, args, duration, easing, cb, scope, type) { + type = type || Ext.lib.AnimBase; + if (typeof easing == "string") { + easing = Ext.lib.Easing[easing]; + } + var anim = new type(el, args, duration, easing); + anim.animateX(function() { + Ext.callback(cb, scope); + }); + return anim; + } + }; + + + function fly(el) { + if (!libFlyweight) { + libFlyweight = new Ext.Element.Flyweight(); + } + libFlyweight.dom = el; + return libFlyweight; + } + + + if(Ext.isIE) { + function fnCleanUp() { + var p = Function.prototype; + delete p.createSequence; + delete p.defer; + delete p.createDelegate; + delete p.createCallback; + delete p.createInterceptor; + + window.detachEvent("onunload", fnCleanUp); + } + window.attachEvent("onunload", fnCleanUp); + } + + Ext.lib.AnimBase = function(el, attributes, duration, method) { + if (el) { + this.init(el, attributes, duration, method); + } + }; + + Ext.lib.AnimBase.prototype = { + + toString: function() { + var el = this.getEl(); + var id = el.id || el.tagName; + return ("Anim " + id); + }, + + patterns: { + noNegatives: /width|height|opacity|padding/i, + offsetAttribute: /^((width|height)|(top|left))$/, + defaultUnit: /width|height|top$|bottom$|left$|right$/i, + offsetUnit: /\d+(em|%|en|ex|pt|in|cm|mm|pc)$/i + }, + + + doMethod: function(attr, start, end) { + return this.method(this.currentFrame, start, end - start, this.totalFrames); + }, + + + setAttribute: function(attr, val, unit) { + if (this.patterns.noNegatives.test(attr)) { + val = (val > 0) ? val : 0; + } + + Ext.fly(this.getEl(), '_anim').setStyle(attr, val + unit); + }, + + + getAttribute: function(attr) { + var el = this.getEl(); + var val = fly(el).getStyle(attr); + + if (val !== 'auto' && !this.patterns.offsetUnit.test(val)) { + return parseFloat(val); + } + + var a = this.patterns.offsetAttribute.exec(attr) || []; + var pos = !!( a[3] ); + var box = !!( a[2] ); + + + if (box || (fly(el).getStyle('position') == 'absolute' && pos)) { + val = el['offset' + a[0].charAt(0).toUpperCase() + a[0].substr(1)]; + } else { + val = 0; + } + + return val; + }, + + + getDefaultUnit: function(attr) { + if (this.patterns.defaultUnit.test(attr)) { + return 'px'; + } + + return ''; + }, + + animateX : function(callback, scope) { + var f = function() { + this.onComplete.removeListener(f); + if (typeof callback == "function") { + callback.call(scope || this, this); + } + }; + this.onComplete.addListener(f, this); + this.animate(); + }, + + + setRuntimeAttribute: function(attr) { + var start; + var end; + var attributes = this.attributes; + + this.runtimeAttributes[attr] = {}; + + var isset = function(prop) { + return (typeof prop !== 'undefined'); + }; + + if (!isset(attributes[attr]['to']) && !isset(attributes[attr]['by'])) { + return false; + } + + start = ( isset(attributes[attr]['from']) ) ? attributes[attr]['from'] : this.getAttribute(attr); + + + if (isset(attributes[attr]['to'])) { + end = attributes[attr]['to']; + } else if (isset(attributes[attr]['by'])) { + if (start.constructor == Array) { + end = []; + for (var i = 0, len = start.length; i < len; ++i) { + end[i] = start[i] + attributes[attr]['by'][i]; + } + } else { + end = start + attributes[attr]['by']; + } + } + + this.runtimeAttributes[attr].start = start; + this.runtimeAttributes[attr].end = end; + + + this.runtimeAttributes[attr].unit = ( isset(attributes[attr].unit) ) ? attributes[attr]['unit'] : this.getDefaultUnit(attr); + }, + + + init: function(el, attributes, duration, method) { + + var isAnimated = false; + + + var startTime = null; + + + var actualFrames = 0; + + + el = Ext.getDom(el); + + + this.attributes = attributes || {}; + + + this.duration = duration || 1; + + + this.method = method || Ext.lib.Easing.easeNone; + + + this.useSeconds = true; + + + this.currentFrame = 0; + + + this.totalFrames = Ext.lib.AnimMgr.fps; + + + this.getEl = function() { + return el; + }; + + + this.isAnimated = function() { + return isAnimated; + }; + + + this.getStartTime = function() { + return startTime; + }; + + this.runtimeAttributes = {}; + + + this.animate = function() { + if (this.isAnimated()) { + return false; + } + + this.currentFrame = 0; + + this.totalFrames = ( this.useSeconds ) ? Math.ceil(Ext.lib.AnimMgr.fps * this.duration) : this.duration; + + Ext.lib.AnimMgr.registerElement(this); + }; + + + this.stop = function(finish) { + if (finish) { + this.currentFrame = this.totalFrames; + this._onTween.fire(); + } + Ext.lib.AnimMgr.stop(this); + }; + + var onStart = function() { + this.onStart.fire(); + + this.runtimeAttributes = {}; + for (var attr in this.attributes) { + this.setRuntimeAttribute(attr); + } + + isAnimated = true; + actualFrames = 0; + startTime = new Date(); + }; + + + var onTween = function() { + var data = { + duration: new Date() - this.getStartTime(), + currentFrame: this.currentFrame + }; + + data.toString = function() { + return ( + 'duration: ' + data.duration + + ', currentFrame: ' + data.currentFrame + ); + }; + + this.onTween.fire(data); + + var runtimeAttributes = this.runtimeAttributes; + + for (var attr in runtimeAttributes) { + this.setAttribute(attr, this.doMethod(attr, runtimeAttributes[attr].start, runtimeAttributes[attr].end), runtimeAttributes[attr].unit); + } + + actualFrames += 1; + }; + + var onComplete = function() { + var actual_duration = (new Date() - startTime) / 1000 ; + + var data = { + duration: actual_duration, + frames: actualFrames, + fps: actualFrames / actual_duration + }; + + data.toString = function() { + return ( + 'duration: ' + data.duration + + ', frames: ' + data.frames + + ', fps: ' + data.fps + ); + }; + + isAnimated = false; + actualFrames = 0; + this.onComplete.fire(data); + }; + + + this._onStart = new Ext.util.Event(this); + this.onStart = new Ext.util.Event(this); + this.onTween = new Ext.util.Event(this); + this._onTween = new Ext.util.Event(this); + this.onComplete = new Ext.util.Event(this); + this._onComplete = new Ext.util.Event(this); + this._onStart.addListener(onStart); + this._onTween.addListener(onTween); + this._onComplete.addListener(onComplete); + } + }; + + + Ext.lib.AnimMgr = new function() { + + var thread = null; + + + var queue = []; + + + var tweenCount = 0; + + + this.fps = 1000; + + + this.delay = 1; + + + this.registerElement = function(tween) { + queue[queue.length] = tween; + tweenCount += 1; + tween._onStart.fire(); + this.start(); + }; + + + this.unRegister = function(tween, index) { + tween._onComplete.fire(); + index = index || getIndex(tween); + if (index != -1) { + queue.splice(index, 1); + } + + tweenCount -= 1; + if (tweenCount <= 0) { + this.stop(); + } + }; + + + this.start = function() { + if (thread === null) { + thread = setInterval(this.run, this.delay); + } + }; + + + this.stop = function(tween) { + if (!tween) { + clearInterval(thread); + + for (var i = 0, len = queue.length; i < len; ++i) { + if (queue[0].isAnimated()) { + this.unRegister(queue[0], 0); + } + } + + queue = []; + thread = null; + tweenCount = 0; + } + else { + this.unRegister(tween); + } + }; + + + this.run = function() { + for (var i = 0, len = queue.length; i < len; ++i) { + var tween = queue[i]; + if (!tween || !tween.isAnimated()) { + continue; + } + + if (tween.currentFrame < tween.totalFrames || tween.totalFrames === null) + { + tween.currentFrame += 1; + + if (tween.useSeconds) { + correctFrame(tween); + } + tween._onTween.fire(); + } + else { + Ext.lib.AnimMgr.stop(tween, i); + } + } + }; + + var getIndex = function(anim) { + for (var i = 0, len = queue.length; i < len; ++i) { + if (queue[i] == anim) { + return i; + } + } + return -1; + }; + + + var correctFrame = function(tween) { + var frames = tween.totalFrames; + var frame = tween.currentFrame; + var expected = (tween.currentFrame * tween.duration * 1000 / tween.totalFrames); + var elapsed = (new Date() - tween.getStartTime()); + var tweak = 0; + + if (elapsed < tween.duration * 1000) { + tweak = Math.round((elapsed / expected - 1) * tween.currentFrame); + } else { + tweak = frames - (frame + 1); + } + if (tweak > 0 && isFinite(tweak)) { + if (tween.currentFrame + tweak >= frames) { + tweak = frames - (frame + 1); + } + + tween.currentFrame += tweak; + } + }; + }; + + Ext.lib.Bezier = new function() { + + this.getPosition = function(points, t) { + var n = points.length; + var tmp = []; + + for (var i = 0; i < n; ++i) { + tmp[i] = [points[i][0], points[i][1]]; + } + + for (var j = 1; j < n; ++j) { + for (i = 0; i < n - j; ++i) { + tmp[i][0] = (1 - t) * tmp[i][0] + t * tmp[parseInt(i + 1, 10)][0]; + tmp[i][1] = (1 - t) * tmp[i][1] + t * tmp[parseInt(i + 1, 10)][1]; + } + } + + return [ tmp[0][0], tmp[0][1] ]; + + }; + }; + (function() { + + Ext.lib.ColorAnim = function(el, attributes, duration, method) { + Ext.lib.ColorAnim.superclass.constructor.call(this, el, attributes, duration, method); + }; + + Ext.extend(Ext.lib.ColorAnim, Ext.lib.AnimBase); + + + var Y = Ext.lib; + var superclass = Y.ColorAnim.superclass; + var proto = Y.ColorAnim.prototype; + + proto.toString = function() { + var el = this.getEl(); + var id = el.id || el.tagName; + return ("ColorAnim " + id); + }; + + proto.patterns.color = /color$/i; + proto.patterns.rgb = /^rgb\(([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\)$/i; + proto.patterns.hex = /^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i; + proto.patterns.hex3 = /^#?([0-9A-F]{1})([0-9A-F]{1})([0-9A-F]{1})$/i; + proto.patterns.transparent = /^transparent|rgba\(0, 0, 0, 0\)$/; + + + proto.parseColor = function(s) { + if (s.length == 3) { + return s; + } + + var c = this.patterns.hex.exec(s); + if (c && c.length == 4) { + return [ parseInt(c[1], 16), parseInt(c[2], 16), parseInt(c[3], 16) ]; + } + + c = this.patterns.rgb.exec(s); + if (c && c.length == 4) { + return [ parseInt(c[1], 10), parseInt(c[2], 10), parseInt(c[3], 10) ]; + } + + c = this.patterns.hex3.exec(s); + if (c && c.length == 4) { + return [ parseInt(c[1] + c[1], 16), parseInt(c[2] + c[2], 16), parseInt(c[3] + c[3], 16) ]; + } + + return null; + }; + + proto.getAttribute = function(attr) { + var el = this.getEl(); + if (this.patterns.color.test(attr)) { + var val = fly(el).getStyle(attr); + + if (this.patterns.transparent.test(val)) { + var parent = el.parentNode; + val = fly(parent).getStyle(attr); + + while (parent && this.patterns.transparent.test(val)) { + parent = parent.parentNode; + val = fly(parent).getStyle(attr); + if (parent.tagName.toUpperCase() == 'HTML') { + val = '#fff'; + } + } + } + } else { + val = superclass.getAttribute.call(this, attr); + } + + return val; + }; + + proto.doMethod = function(attr, start, end) { + var val; + + if (this.patterns.color.test(attr)) { + val = []; + for (var i = 0, len = start.length; i < len; ++i) { + val[i] = superclass.doMethod.call(this, attr, start[i], end[i]); + } + + val = 'rgb(' + Math.floor(val[0]) + ',' + Math.floor(val[1]) + ',' + Math.floor(val[2]) + ')'; + } + else { + val = superclass.doMethod.call(this, attr, start, end); + } + + return val; + }; + + proto.setRuntimeAttribute = function(attr) { + superclass.setRuntimeAttribute.call(this, attr); + + if (this.patterns.color.test(attr)) { + var attributes = this.attributes; + var start = this.parseColor(this.runtimeAttributes[attr].start); + var end = this.parseColor(this.runtimeAttributes[attr].end); + + if (typeof attributes[attr]['to'] === 'undefined' && typeof attributes[attr]['by'] !== 'undefined') { + end = this.parseColor(attributes[attr].by); + + for (var i = 0, len = start.length; i < len; ++i) { + end[i] = start[i] + end[i]; + } + } + + this.runtimeAttributes[attr].start = start; + this.runtimeAttributes[attr].end = end; + } + }; + })(); + + + Ext.lib.Easing = { + + + easeNone: function (t, b, c, d) { + return c * t / d + b; + }, + + + easeIn: function (t, b, c, d) { + return c * (t /= d) * t + b; + }, + + + easeOut: function (t, b, c, d) { + return -c * (t /= d) * (t - 2) + b; + }, + + + easeBoth: function (t, b, c, d) { + if ((t /= d / 2) < 1) { + return c / 2 * t * t + b; + } + + return -c / 2 * ((--t) * (t - 2) - 1) + b; + }, + + + easeInStrong: function (t, b, c, d) { + return c * (t /= d) * t * t * t + b; + }, + + + easeOutStrong: function (t, b, c, d) { + return -c * ((t = t / d - 1) * t * t * t - 1) + b; + }, + + + easeBothStrong: function (t, b, c, d) { + if ((t /= d / 2) < 1) { + return c / 2 * t * t * t * t + b; + } + + return -c / 2 * ((t -= 2) * t * t * t - 2) + b; + }, + + + + elasticIn: function (t, b, c, d, a, p) { + if (t == 0) { + return b; + } + if ((t /= d) == 1) { + return b + c; + } + if (!p) { + p = d * .3; + } + + if (!a || a < Math.abs(c)) { + a = c; + var s = p / 4; + } + else { + var s = p / (2 * Math.PI) * Math.asin(c / a); + } + + return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b; + }, + + + elasticOut: function (t, b, c, d, a, p) { + if (t == 0) { + return b; + } + if ((t /= d) == 1) { + return b + c; + } + if (!p) { + p = d * .3; + } + + if (!a || a < Math.abs(c)) { + a = c; + var s = p / 4; + } + else { + var s = p / (2 * Math.PI) * Math.asin(c / a); + } + + return a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b; + }, + + + elasticBoth: function (t, b, c, d, a, p) { + if (t == 0) { + return b; + } + + if ((t /= d / 2) == 2) { + return b + c; + } + + if (!p) { + p = d * (.3 * 1.5); + } + + if (!a || a < Math.abs(c)) { + a = c; + var s = p / 4; + } + else { + var s = p / (2 * Math.PI) * Math.asin(c / a); + } + + if (t < 1) { + return -.5 * (a * Math.pow(2, 10 * (t -= 1)) * + Math.sin((t * d - s) * (2 * Math.PI) / p)) + b; + } + return a * Math.pow(2, -10 * (t -= 1)) * + Math.sin((t * d - s) * (2 * Math.PI) / p) * .5 + c + b; + }, + + + + backIn: function (t, b, c, d, s) { + if (typeof s == 'undefined') { + s = 1.70158; + } + return c * (t /= d) * t * ((s + 1) * t - s) + b; + }, + + + backOut: function (t, b, c, d, s) { + if (typeof s == 'undefined') { + s = 1.70158; + } + return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b; + }, + + + backBoth: function (t, b, c, d, s) { + if (typeof s == 'undefined') { + s = 1.70158; + } + + if ((t /= d / 2 ) < 1) { + return c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b; + } + return c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b; + }, + + + bounceIn: function (t, b, c, d) { + return c - Ext.lib.Easing.bounceOut(d - t, 0, c, d) + b; + }, + + + bounceOut: function (t, b, c, d) { + if ((t /= d) < (1 / 2.75)) { + return c * (7.5625 * t * t) + b; + } else if (t < (2 / 2.75)) { + return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b; + } else if (t < (2.5 / 2.75)) { + return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b; + } + return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b; + }, + + + bounceBoth: function (t, b, c, d) { + if (t < d / 2) { + return Ext.lib.Easing.bounceIn(t * 2, 0, c, d) * .5 + b; + } + return Ext.lib.Easing.bounceOut(t * 2 - d, 0, c, d) * .5 + c * .5 + b; + } + }; + + (function() { + Ext.lib.Motion = function(el, attributes, duration, method) { + if (el) { + Ext.lib.Motion.superclass.constructor.call(this, el, attributes, duration, method); + } + }; + + Ext.extend(Ext.lib.Motion, Ext.lib.ColorAnim); + + + var Y = Ext.lib; + var superclass = Y.Motion.superclass; + var proto = Y.Motion.prototype; + + proto.toString = function() { + var el = this.getEl(); + var id = el.id || el.tagName; + return ("Motion " + id); + }; + + proto.patterns.points = /^points$/i; + + proto.setAttribute = function(attr, val, unit) { + if (this.patterns.points.test(attr)) { + unit = unit || 'px'; + superclass.setAttribute.call(this, 'left', val[0], unit); + superclass.setAttribute.call(this, 'top', val[1], unit); + } else { + superclass.setAttribute.call(this, attr, val, unit); + } + }; + + proto.getAttribute = function(attr) { + if (this.patterns.points.test(attr)) { + var val = [ + superclass.getAttribute.call(this, 'left'), + superclass.getAttribute.call(this, 'top') + ]; + } else { + val = superclass.getAttribute.call(this, attr); + } + + return val; + }; + + proto.doMethod = function(attr, start, end) { + var val = null; + + if (this.patterns.points.test(attr)) { + var t = this.method(this.currentFrame, 0, 100, this.totalFrames) / 100; + val = Y.Bezier.getPosition(this.runtimeAttributes[attr], t); + } else { + val = superclass.doMethod.call(this, attr, start, end); + } + return val; + }; + + proto.setRuntimeAttribute = function(attr) { + if (this.patterns.points.test(attr)) { + var el = this.getEl(); + var attributes = this.attributes; + var start; + var control = attributes['points']['control'] || []; + var end; + var i, len; + + if (control.length > 0 && !Ext.isArray(control[0])) { + control = [control]; + } else { + var tmp = []; + for (i = 0,len = control.length; i < len; ++i) { + tmp[i] = control[i]; + } + control = tmp; + } + + Ext.fly(el).position(); + + if (isset(attributes['points']['from'])) { + Ext.lib.Dom.setXY(el, attributes['points']['from']); + } + else { + Ext.lib.Dom.setXY(el, Ext.lib.Dom.getXY(el)); + } + + start = this.getAttribute('points'); + + + if (isset(attributes['points']['to'])) { + end = translateValues.call(this, attributes['points']['to'], start); + + var pageXY = Ext.lib.Dom.getXY(this.getEl()); + for (i = 0,len = control.length; i < len; ++i) { + control[i] = translateValues.call(this, control[i], start); + } + + + } else if (isset(attributes['points']['by'])) { + end = [ start[0] + attributes['points']['by'][0], start[1] + attributes['points']['by'][1] ]; + + for (i = 0,len = control.length; i < len; ++i) { + control[i] = [ start[0] + control[i][0], start[1] + control[i][1] ]; + } + } + + this.runtimeAttributes[attr] = [start]; + + if (control.length > 0) { + this.runtimeAttributes[attr] = this.runtimeAttributes[attr].concat(control); + } + + this.runtimeAttributes[attr][this.runtimeAttributes[attr].length] = end; + } + else { + superclass.setRuntimeAttribute.call(this, attr); + } + }; + + var translateValues = function(val, start) { + var pageXY = Ext.lib.Dom.getXY(this.getEl()); + val = [ val[0] - pageXY[0] + start[0], val[1] - pageXY[1] + start[1] ]; + + return val; + }; + + var isset = function(prop) { + return (typeof prop !== 'undefined'); + }; + })(); + + + (function() { + Ext.lib.Scroll = function(el, attributes, duration, method) { + if (el) { + Ext.lib.Scroll.superclass.constructor.call(this, el, attributes, duration, method); + } + }; + + Ext.extend(Ext.lib.Scroll, Ext.lib.ColorAnim); + + + var Y = Ext.lib; + var superclass = Y.Scroll.superclass; + var proto = Y.Scroll.prototype; + + proto.toString = function() { + var el = this.getEl(); + var id = el.id || el.tagName; + return ("Scroll " + id); + }; + + proto.doMethod = function(attr, start, end) { + var val = null; + + if (attr == 'scroll') { + val = [ + this.method(this.currentFrame, start[0], end[0] - start[0], this.totalFrames), + this.method(this.currentFrame, start[1], end[1] - start[1], this.totalFrames) + ]; + + } else { + val = superclass.doMethod.call(this, attr, start, end); + } + return val; + }; + + proto.getAttribute = function(attr) { + var val = null; + var el = this.getEl(); + + if (attr == 'scroll') { + val = [ el.scrollLeft, el.scrollTop ]; + } else { + val = superclass.getAttribute.call(this, attr); + } + + return val; + }; + + proto.setAttribute = function(attr, val, unit) { + var el = this.getEl(); + + if (attr == 'scroll') { + el.scrollLeft = val[0]; + el.scrollTop = val[1]; + } else { + superclass.setAttribute.call(this, attr, val, unit); + } + }; + })(); + + +})(); +