| New file |
|---|
| 0,0 → 1,537 |
|---|
| /* |
| * Ext JS Library 2.0.2 |
| * Copyright(c) 2006-2008, Ext JS, LLC. |
| * licensing@extjs.com |
| * |
| * http://extjs.com/license |
| */ |
| |
| if(typeof jQuery == "undefined"){ |
| throw "Unable to load Ext, jQuery not found."; |
| } |
| |
| (function(){ |
| var libFlyweight; |
| |
| Ext.lib.Dom = { |
| getViewWidth : function(full){ |
| // jQuery doesn't report full window size on document query, so max both |
| return full ? Math.max(jQuery(document).width(),jQuery(window).width()) : jQuery(window).width(); |
| }, |
| |
| getViewHeight : function(full){ |
| // jQuery doesn't report full window size on document query, so max both |
| return full ? Math.max(jQuery(document).height(),jQuery(window).height()) : jQuery(window).height(); |
| }, |
| |
| isAncestor : function(p, c){ |
| p = Ext.getDom(p); |
| c = Ext.getDom(c); |
| if (!p || !c) {return false;} |
| |
| if(p.contains && !Ext.isSafari) { |
| return p.contains(c); |
| }else if(p.compareDocumentPosition) { |
| return !!(p.compareDocumentPosition(c) & 16); |
| }else{ |
| var parent = c.parentNode; |
| while (parent) { |
| if (parent == p) { |
| return true; |
| } |
| else if (!parent.tagName || parent.tagName.toUpperCase() == "HTML") { |
| return false; |
| } |
| parent = parent.parentNode; |
| } |
| return false; |
| } |
| }, |
| |
| getRegion : function(el){ |
| return Ext.lib.Region.getRegion(el); |
| }, |
| |
| ////////////////////////////////////////////////////////////////////////////////////// |
| // Use of jQuery.offset() removed to promote consistent behavior across libs. |
| // JVS 05/23/07 |
| ////////////////////////////////////////////////////////////////////////////////////// |
| |
| getY : function(el){ |
| return this.getXY(el)[1]; |
| }, |
| |
| getX : function(el){ |
| return this.getXY(el)[0]; |
| }, |
| |
| getXY : function(el) { |
| var p, pe, b, scroll, bd = (document.body || document.documentElement); |
| el = Ext.getDom(el); |
| |
| if(el == bd){ |
| return [0, 0]; |
| } |
| |
| if (el.getBoundingClientRect) { |
| b = el.getBoundingClientRect(); |
| scroll = fly(document).getScroll(); |
| return [b.left + scroll.left, b.top + scroll.top]; |
| } |
| var x = 0, y = 0; |
| |
| p = el; |
| |
| var hasAbsolute = fly(el).getStyle("position") == "absolute"; |
| |
| while (p) { |
| |
| x += p.offsetLeft; |
| y += p.offsetTop; |
| |
| if (!hasAbsolute && fly(p).getStyle("position") == "absolute") { |
| hasAbsolute = true; |
| } |
| |
| if (Ext.isGecko) { |
| pe = fly(p); |
| |
| var bt = parseInt(pe.getStyle("borderTopWidth"), 10) || 0; |
| var bl = parseInt(pe.getStyle("borderLeftWidth"), 10) || 0; |
| |
| |
| x += bl; |
| y += bt; |
| |
| |
| if (p != el && pe.getStyle('overflow') != 'visible') { |
| x += bl; |
| y += bt; |
| } |
| } |
| p = p.offsetParent; |
| } |
| |
| if (Ext.isSafari && hasAbsolute) { |
| x -= bd.offsetLeft; |
| y -= bd.offsetTop; |
| } |
| |
| if (Ext.isGecko && !hasAbsolute) { |
| var dbd = fly(bd); |
| x += parseInt(dbd.getStyle("borderLeftWidth"), 10) || 0; |
| y += parseInt(dbd.getStyle("borderTopWidth"), 10) || 0; |
| } |
| |
| p = el.parentNode; |
| while (p && p != bd) { |
| if (!Ext.isOpera || (p.tagName != 'TR' && fly(p).getStyle("display") != "inline")) { |
| x -= p.scrollLeft; |
| y -= p.scrollTop; |
| } |
| p = p.parentNode; |
| } |
| return [x, y]; |
| }, |
| |
| setXY : function(el, xy){ |
| el = Ext.fly(el, '_setXY'); |
| el.position(); |
| var pts = el.translatePoints(xy); |
| if(xy[0] !== false){ |
| el.dom.style.left = pts.left + "px"; |
| } |
| if(xy[1] !== false){ |
| el.dom.style.top = pts.top + "px"; |
| } |
| }, |
| |
| setX : function(el, x){ |
| this.setXY(el, [x, false]); |
| }, |
| |
| setY : function(el, y){ |
| this.setXY(el, [false, y]); |
| } |
| }; |
| |
| // all lib flyweight calls use their own flyweight to prevent collisions with developer flyweights |
| function fly(el){ |
| if(!libFlyweight){ |
| libFlyweight = new Ext.Element.Flyweight(); |
| } |
| libFlyweight.dom = el; |
| return libFlyweight; |
| } |
| Ext.lib.Event = { |
| getPageX : function(e){ |
| e = e.browserEvent || e; |
| return e.pageX; |
| }, |
| |
| getPageY : function(e){ |
| e = e.browserEvent || e; |
| return e.pageY; |
| }, |
| |
| getXY : function(e){ |
| e = e.browserEvent || e; |
| return [e.pageX, e.pageY]; |
| }, |
| |
| getTarget : function(e){ |
| return e.target; |
| }, |
| |
| // all Ext events will go through event manager which provides scoping |
| on : function(el, eventName, fn, scope, override){ |
| jQuery(el).bind(eventName, fn); |
| }, |
| |
| un : function(el, eventName, fn){ |
| jQuery(el).unbind(eventName, fn); |
| }, |
| |
| purgeElement : function(el){ |
| jQuery(el).unbind(); |
| }, |
| |
| preventDefault : function(e){ |
| e = e.browserEvent || e; |
| if(e.preventDefault){ |
| e.preventDefault(); |
| }else{ |
| e.returnValue = false; |
| } |
| }, |
| |
| stopPropagation : function(e){ |
| e = e.browserEvent || e; |
| if(e.stopPropagation){ |
| e.stopPropagation(); |
| }else{ |
| e.cancelBubble = true; |
| } |
| }, |
| |
| stopEvent : function(e){ |
| this.preventDefault(e); |
| this.stopPropagation(e); |
| }, |
| |
| onAvailable : function(id, fn, scope){ |
| var start = new Date(); |
| var f = function(){ |
| if(start.getElapsed() > 10000){ |
| clearInterval(iid); |
| } |
| var el = document.getElementById(id); |
| if(el){ |
| clearInterval(iid); |
| fn.call(scope||window, el); |
| } |
| }; |
| var iid = setInterval(f, 50); |
| }, |
| |
| resolveTextNode: function(node) { |
| if (node && 3 == node.nodeType) { |
| return node.parentNode; |
| } else { |
| return node; |
| } |
| }, |
| |
| 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); |
| } |
| }; |
| |
| Ext.lib.Ajax = function(){ |
| var createComplete = function(cb){ |
| return function(xhr, status){ |
| if((status == 'error' || status == 'timeout') && cb.failure){ |
| cb.failure.call(cb.scope||window, { |
| responseText: xhr.responseText, |
| responseXML : xhr.responseXML, |
| argument: cb.argument |
| }); |
| }else if(cb.success){ |
| cb.success.call(cb.scope||window, { |
| responseText: xhr.responseText, |
| responseXML : xhr.responseXML, |
| argument: cb.argument |
| }); |
| } |
| }; |
| }; |
| return { |
| request : function(method, uri, cb, data, options){ |
| var o = { |
| type: method, |
| url: uri, |
| data: data, |
| timeout: cb.timeout, |
| complete: createComplete(cb) |
| }; |
| |
| if(options){ |
| if(options.xmlData){ |
| o.data = options.xmlData; |
| o.processData = false; |
| o.type = 'POST'; |
| o.contentType = 'text/xml'; |
| }else if(options.jsonData){ |
| o.data = typeof options.jsonData == 'object' ? Ext.encode(options.jsonData) : options.jsonData; |
| o.processData = false; |
| o.type = 'POST'; |
| o.contentType = 'text/javascript'; |
| } |
| if(options.headers){ |
| o.beforeSend = function(xhr){ |
| var hs = options.headers; |
| for(var h in hs){ |
| if(hs.hasOwnProperty(h)){ |
| xhr.setRequestHeader(h, hs[h]); |
| } |
| } |
| } |
| } |
| } |
| jQuery.ajax(o); |
| }, |
| |
| formRequest : function(form, uri, cb, data, isUpload, sslUri){ |
| jQuery.ajax({ |
| type: Ext.getDom(form).method ||'POST', |
| url: uri, |
| data: jQuery(form).serialize()+(data?'&'+data:''), |
| timeout: cb.timeout, |
| complete: createComplete(cb) |
| }); |
| }, |
| |
| isCallInProgress : function(trans){ |
| return false; |
| }, |
| |
| abort : function(trans){ |
| return false; |
| }, |
| |
| serializeForm : function(form){ |
| return jQuery(form.dom||form).serialize(); |
| } |
| }; |
| }(); |
| |
| Ext.lib.Anim = function(){ |
| var createAnim = function(cb, scope){ |
| var animated = true; |
| return { |
| stop : function(skipToLast){ |
| // do nothing |
| }, |
| |
| isAnimated : function(){ |
| return animated; |
| }, |
| |
| proxyCallback : function(){ |
| animated = false; |
| Ext.callback(cb, scope); |
| } |
| }; |
| }; |
| return { |
| scroll : function(el, args, duration, easing, cb, scope){ |
| // scroll anim not supported so just scroll immediately |
| var anim = createAnim(cb, scope); |
| el = Ext.getDom(el); |
| if(typeof args.scroll.to[0] == 'number'){ |
| el.scrollLeft = args.scroll.to[0]; |
| } |
| if(typeof args.scroll.to[1] == 'number'){ |
| el.scrollTop = args.scroll.to[1]; |
| } |
| anim.proxyCallback(); |
| return anim; |
| }, |
| |
| motion : function(el, args, duration, easing, cb, scope){ |
| return this.run(el, args, duration, easing, cb, scope); |
| }, |
| |
| color : function(el, args, duration, easing, cb, scope){ |
| // color anim not supported, so execute callback immediately |
| var anim = createAnim(cb, scope); |
| anim.proxyCallback(); |
| return anim; |
| }, |
| |
| run : function(el, args, duration, easing, cb, scope, type){ |
| var anim = createAnim(cb, scope), e = Ext.fly(el, '_animrun'); |
| var o = {}; |
| for(var k in args){ |
| if(args[k].from){ |
| if(k != 'points'){ |
| e.setStyle(k, args[k].from); |
| } |
| } |
| switch(k){ // jquery doesn't support, so convert |
| case 'points': |
| var by, pts; |
| e.position(); |
| if(by = args.points.by){ |
| var xy = e.getXY(); |
| pts = e.translatePoints([xy[0]+by[0], xy[1]+by[1]]); |
| }else{ |
| pts = e.translatePoints(args.points.to); |
| } |
| o.left = pts.left; |
| o.top = pts.top; |
| if(!parseInt(e.getStyle('left'), 10)){ // auto bug |
| e.setLeft(0); |
| } |
| if(!parseInt(e.getStyle('top'), 10)){ |
| e.setTop(0); |
| } |
| if(args.points.from){ |
| e.setXY(args.points.from); |
| } |
| break; |
| case 'width': |
| o.width = args.width.to; |
| break; |
| case 'height': |
| o.height = args.height.to; |
| break; |
| case 'opacity': |
| o.opacity = args.opacity.to; |
| break; |
| case 'left': |
| o.left = args.left.to; |
| break; |
| case 'top': |
| o.top = args.top.to; |
| break; |
| default: |
| o[k] = args[k].to; |
| break; |
| } |
| } |
| // TODO: find out about easing plug in? |
| jQuery(el).animate(o, duration*1000, undefined, anim.proxyCallback); |
| return anim; |
| } |
| }; |
| }(); |
| |
| |
| 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(); |
| |
| // prevent IE leaks |
| 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); |
| } |
| })(); |