lpmp 1.0.0

data/public/ext-3.0.0/src/adapter/core/ext-base-begin.js

@@ -0,0 +1,18 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+(function(){
+	var libFlyweight;
+	
+	function fly(el) {
+        if (!libFlyweight) {
+            libFlyweight = new Ext.Element.Flyweight();
+        }
+        libFlyweight.dom = el;
+        return libFlyweight;
+    }
+    
+    

data/public/ext-3.0.0/src/adapter/core/ext-base-dom.js

@@ -0,0 +1,157 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+(function(){
+	var doc = document,
+		isCSS1 = doc.compatMode == "CSS1Compat",
+		MAX = Math.max,		
+		PARSEINT = parseInt;
+		
+	Ext.lib.Dom = {
+	    isAncestor : function(p, c) {
+		    var ret = false;
+			
+			p = Ext.getDom(p);
+			c = Ext.getDom(c);
+			if (p && c) {
+				if (p.contains) {
+					return p.contains(c);
+				} else if (p.compareDocumentPosition) {
+					return !!(p.compareDocumentPosition(c) & 16);
+				} else {
+					while (c = c.parentNode) {
+						ret = c == p || ret;	        			
+					}
+				}	            
+			}	
+			return ret;
+		},
+		
+        getViewWidth : function(full) {
+            return full ? this.getDocumentWidth() : this.getViewportWidth();
+        },
+
+        getViewHeight : function(full) {
+            return full ? this.getDocumentHeight() : this.getViewportHeight();
+        },
+
+        getDocumentHeight: function() {            
+            return MAX(!isCSS1 ? doc.body.scrollHeight : doc.documentElement.scrollHeight, this.getViewportHeight());
+        },
+
+        getDocumentWidth: function() {            
+            return MAX(!isCSS1 ? doc.body.scrollWidth : doc.documentElement.scrollWidth, this.getViewportWidth());
+        },
+
+        getViewportHeight: function(){
+	        return Ext.isIE ? 
+	        	   (Ext.isStrict ? doc.documentElement.clientHeight : doc.body.clientHeight) :
+	        	   self.innerHeight;
+        },
+
+        getViewportWidth : function() {
+	        return !Ext.isStrict && !Ext.isOpera ? doc.body.clientWidth :
+	        	   Ext.isIE ? doc.documentElement.clientWidth : self.innerWidth;
+        },
+        
+        getY : function(el) {
+            return this.getXY(el)[1];
+        },
+
+        getX : function(el) {
+            return this.getXY(el)[0];
+        },
+
+        getXY : function(el) {
+            var p, 
+            	pe, 
+            	b,
+            	bt, 
+            	bl,     
+            	dbd,       	
+            	x = 0,
+            	y = 0, 
+            	scroll,
+            	hasAbsolute, 
+            	bd = (doc.body || doc.documentElement),
+            	ret = [0,0];
+            	
+            el = Ext.getDom(el);
+
+            if(el != bd){
+	            if (el.getBoundingClientRect) {
+	                b = el.getBoundingClientRect();
+	                scroll = fly(document).getScroll();
+	                ret = [b.left + scroll.left, b.top + scroll.top];
+	            } else {  
+		            p = el;		
+		            hasAbsolute = fly(el).isStyle("position", "absolute");
+		
+		            while (p) {
+			            pe = fly(p);		
+		                x += p.offsetLeft;
+		                y += p.offsetTop;
+		
+		                hasAbsolute = hasAbsolute || pe.isStyle("position", "absolute");
+		                		
+		                if (Ext.isGecko) {		                    
+		                    y += bt = PARSEINT(pe.getStyle("borderTopWidth"), 10) || 0;
+		                    x += bl = PARSEINT(pe.getStyle("borderLeftWidth"), 10) || 0;	
+		
+		                    if (p != el && !pe.isStyle('overflow','visible')) {
+		                        x += bl;
+		                        y += bt;
+		                    }
+		                }
+		                p = p.offsetParent;
+		            }
+		
+		            if (Ext.isSafari && hasAbsolute) {
+		                x -= bd.offsetLeft;
+		                y -= bd.offsetTop;
+		            }
+		
+		            if (Ext.isGecko && !hasAbsolute) {
+		                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).isStyle("display", "inline"))) {
+		                    x -= p.scrollLeft;
+		                    y -= p.scrollTop;
+		                }
+		                p = p.parentNode;
+		            }
+		            ret = [x,y];
+	            }
+         	}
+            return ret
+        },
+
+        setXY : function(el, xy) {
+            (el = Ext.fly(el, '_setXY')).position();
+            
+            var pts = el.translatePoints(xy),
+            	style = el.dom.style,
+            	pos;            	
+            
+            for (pos in pts) {	            
+	            if(!isNaN(pts[pos])) style[pos] = pts[pos] + "px"
+            }
+        },
+
+        setX : function(el, x) {
+            this.setXY(el, [x, false]);
+        },
+
+        setY : function(el, y) {
+            this.setXY(el, [false, y]);
+        }
+    };
+})();

data/public/ext-3.0.0/src/adapter/core/ext-base-end.js

@@ -0,0 +1,21 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+	
+	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);
+    }
+})();

data/public/ext-3.0.0/src/adapter/core/ext-base-event.js

@@ -0,0 +1,453 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+Ext.lib.Event = function() {
+    var loadComplete = false,
+        listeners = [],
+        unloadListeners = [],
+        retryCount = 0,
+        onAvailStack = [],
+        _interval,
+        locked = false,
+        win = window,
+        doc = document,
+        
+        // constants            
+        POLL_RETRYS = 200,
+        POLL_INTERVAL = 20,
+        EL = 0,
+        TYPE = 1,
+        FN = 2,
+        WFN = 3,
+        OBJ = 3,
+        ADJ_SCOPE = 4,   
+        SCROLLLEFT = 'scrollLeft',
+        SCROLLTOP = 'scrollTop',
+        UNLOAD = 'unload',
+        MOUSEOVER = 'mouseover',
+        MOUSEOUT = 'mouseout',
+        // private
+        doAdd = function() {
+            var ret;
+            if (win.addEventListener) {
+                ret = function(el, eventName, fn, capture) {
+                    if (eventName == 'mouseenter') {
+                        fn = fn.createInterceptor(checkRelatedTarget);
+                        el.addEventListener(MOUSEOVER, fn, (capture));
+                    } else if (eventName == 'mouseleave') {
+                        fn = fn.createInterceptor(checkRelatedTarget);
+                        el.addEventListener(MOUSEOUT, fn, (capture));
+                    } else {
+                        el.addEventListener(eventName, fn, (capture));
+                    }
+                    return fn;
+                };
+            } else if (win.attachEvent) {
+                ret = function(el, eventName, fn, capture) {
+                    el.attachEvent("on" + eventName, fn);
+                    return fn;
+                };
+            } else {
+                ret = function(){};
+            }
+            return ret;
+        }(),    
+        // private
+        doRemove = function(){
+            var ret;
+            if (win.removeEventListener) {
+                ret = function (el, eventName, fn, capture) {
+                    if (eventName == 'mouseenter') {
+                        eventName = MOUSEOVER;
+                    } else if (eventName == 'mouseleave') {
+                        eventName = MOUSEOUT;
+                    }                        
+                    el.removeEventListener(eventName, fn, (capture));
+                };
+            } else if (win.detachEvent) {
+                ret = function (el, eventName, fn) {
+                    el.detachEvent("on" + eventName, fn);
+                };
+            } else {
+                ret = function(){};
+            }
+            return ret;
+        }();        
+
+    var isXUL = Ext.isGecko ? function(node){ 
+        return Object.prototype.toString.call(node) == '[object XULElement]';
+    } : function(){};
+        
+    var isTextNode = Ext.isGecko ? function(node){
+        try{
+            return node.nodeType == 3;
+        }catch(e) {
+            return false;
+        }
+
+    } : function(node){
+        return node.nodeType == 3;
+    };
+        
+    function checkRelatedTarget(e) {
+        var related = pub.getRelatedTarget(e);
+        return !(isXUL(related) || elContains(e.currentTarget,related));
+    }
+
+    function elContains(parent, child) {
+       if(parent && parent.firstChild){  
+         while(child) {
+            if(child === parent) {
+                return true;
+            }
+            try {
+                child = child.parentNode;
+            } catch(e) {
+                // In FF if you mouseout an text input element
+                // thats inside a div sometimes it randomly throws
+                // Permission denied to get property HTMLDivElement.parentNode
+                // See https://bugzilla.mozilla.org/show_bug.cgi?id=208427
+                
+                return false;
+            }                
+            if(child && (child.nodeType != 1)) {
+                child = null;
+            }
+          }
+        }
+        return false;
+    }
+
+        
+    // private  
+    function _getCacheIndex(el, eventName, fn) {
+        var index = -1;
+        Ext.each(listeners, function (v,i) {
+            if(v && v[FN] == fn && v[EL] == el && v[TYPE] == eventName) {
+                index = i;
+            }
+        });
+        return index;
+    }
+                    
+    // private
+    function _tryPreloadAttach() {
+        var ret = false,                
+            notAvail = [],
+            element,
+            tryAgain = !loadComplete || (retryCount > 0);                       
+        
+        if (!locked) {
+            locked = true;
+            
+            Ext.each(onAvailStack, function (v,i,a){
+                if(v && (element = doc.getElementById(v.id))){
+                    if(!v.checkReady || loadComplete || element.nextSibling || (doc && doc.body)) {
+                        element = v.override ? (v.override === true ? v.obj : v.override) : element;
+                        v.fn.call(element, v.obj);
+                        onAvailStack[i] = null;
+                    } else {
+                        notAvail.push(v);
+                    }
+                }   
+            });
+
+            retryCount = (notAvail.length === 0) ? 0 : retryCount - 1;
+
+            if (tryAgain) { 
+                startInterval();
+            } else {
+                clearInterval(_interval);
+                _interval = null;
+            }
+
+            ret = !(locked = false);
+        }
+        return ret;
+    }
+    
+    // private              
+    function startInterval() {            
+        if(!_interval){                    
+            var callback = function() {
+                _tryPreloadAttach();
+            };
+            _interval = setInterval(callback, POLL_INTERVAL);
+        }
+    }
+    
+    // private 
+    function getScroll() {
+        var dd = doc.documentElement, 
+            db = doc.body;
+        if(dd && (dd[SCROLLTOP] || dd[SCROLLLEFT])){
+            return [dd[SCROLLLEFT], dd[SCROLLTOP]];
+        }else if(db){
+            return [db[SCROLLLEFT], db[SCROLLTOP]];
+        }else{
+            return [0, 0];
+        }
+    }
+        
+    // private
+    function getPageCoord (ev, xy) {
+        ev = ev.browserEvent || ev;
+        var coord  = ev['page' + xy];
+        if (!coord && coord !== 0) {
+            coord = ev['client' + xy] || 0;
+
+            if (Ext.isIE) {
+                coord += getScroll()[xy == "X" ? 0 : 1];
+            }
+        }
+
+        return coord;
+    }
+
+    var pub =  {
+        onAvailable : function(p_id, p_fn, p_obj, p_override) {             
+            onAvailStack.push({ 
+                id:         p_id,
+                fn:         p_fn,
+                obj:        p_obj,
+                override:   p_override,
+                checkReady: false });
+
+            retryCount = POLL_RETRYS;
+            startInterval();
+        },
+
+
+        addListener: function(el, eventName, fn) {
+            var ret;                
+            el = Ext.getDom(el);                
+            if (el && fn) {
+                if (UNLOAD == eventName) {
+                    ret = !!(unloadListeners[unloadListeners.length] = [el, eventName, fn]);                    
+                } else {
+                    listeners.push([el, eventName, fn, ret = doAdd(el, eventName, fn, false)]);
+                }
+            }
+            return !!ret;
+        },
+
+        removeListener: function(el, eventName, fn) {
+            var ret = false,
+                index, 
+                cacheItem;
+
+            el = Ext.getDom(el);
+
+            if(!fn) {                   
+                ret = this.purgeElement(el, false, eventName);
+            } else if (UNLOAD == eventName) {   
+                Ext.each(unloadListeners, function(v, i, a) {
+                    if( v && v[0] == el && v[1] == eventName && v[2] == fn) {
+                        unloadListeners.splice(i, 1);
+                        ret = true;
+                    }
+                });
+            } else {    
+                index = arguments[3] || _getCacheIndex(el, eventName, fn);
+                cacheItem = listeners[index];
+                
+                if (el && cacheItem) {
+                    doRemove(el, eventName, cacheItem[WFN], false);     
+                    cacheItem[WFN] = cacheItem[FN] = null;                       
+                    listeners.splice(index, 1);     
+                    ret = true;
+                }
+            }
+            return ret;
+        },
+
+        getTarget : function(ev) {
+            ev = ev.browserEvent || ev;                
+            return this.resolveTextNode(ev.target || ev.srcElement);
+        },
+
+        resolveTextNode : function(node) {
+            return node && !isXUL(node) && isTextNode(node) ? node.parentNode : node;
+        },
+
+        getRelatedTarget : function(ev) {
+            ev = ev.browserEvent || ev;
+            return this.resolveTextNode(ev.relatedTarget || 
+                    (ev.type == MOUSEOUT ? ev.toElement :
+                     ev.type == MOUSEOVER ? ev.fromElement : null));
+        },
+        
+        getPageX : function(ev) {
+            return getPageCoord(ev, "X");
+        },
+
+        getPageY : function(ev) {
+            return getPageCoord(ev, "Y");
+        },
+
+
+        getXY : function(ev) {                             
+            return [this.getPageX(ev), this.getPageY(ev)];
+        },
+
+// Is this useful?  Removing to save space unless use case exists.
+//             getTime: function(ev) {
+//                 ev = ev.browserEvent || ev;
+//                 if (!ev.time) {
+//                     var t = new Date().getTime();
+//                     try {
+//                         ev.time = t;
+//                     } catch(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) {
+            e = e || win.event;
+            if (!e) {
+                var c = this.getEvent.caller;
+                while (c) {
+                    e = c.arguments[0];
+                    if (e && Event == e.constructor) {
+                        break;
+                    }
+                    c = c.caller;
+                }
+            }
+            return e;
+        },
+
+        getCharCode : function(ev) {
+            ev = ev.browserEvent || ev;
+            return ev.charCode || ev.keyCode || 0;
+        },
+
+        //clearCache: function() {},
+
+        _load : function(e) {
+            loadComplete = true;
+            var EU = Ext.lib.Event;    
+            if (Ext.isIE && e !== true) {
+        // IE8 complains that _load is null or not an object
+        // so lets remove self via arguments.callee
+                doRemove(win, "load", arguments.callee);
+            }
+        },            
+        
+        purgeElement : function(el, recurse, eventName) {
+            var me = this;
+            Ext.each( me.getListeners(el, eventName), function(v){
+                if(v){
+                    me.removeListener(el, v.type, v.fn);
+                }
+            });
+
+            if (recurse && el && el.childNodes) {
+                Ext.each(el.childNodes, function(v){
+                    me.purgeElement(v, recurse, eventName);
+                });
+            }
+        },
+
+        getListeners : function(el, eventName) {
+            var me = this,
+                results = [], 
+                searchLists;
+
+            if (eventName){  
+                searchLists = eventName == UNLOAD ? unloadListeners : listeners;
+            }else{
+                searchLists = listeners.concat(unloadListeners);
+            }
+
+            Ext.each(searchLists, function(v, i){
+                if (v && v[EL] == el && (!eventName || eventName == v[TYPE])) {
+                    results.push({
+                                type:   v[TYPE],
+                                fn:     v[FN],
+                                obj:    v[OBJ],
+                                adjust: v[ADJ_SCOPE],
+                                index:  i
+                            });
+                }   
+            });                
+
+            return results.length ? results : null;
+        },
+
+        _unload : function(e) {
+             var EU = Ext.lib.Event, 
+                i, 
+                j, 
+                l, 
+                len, 
+                index,
+                scope;
+                
+
+            Ext.each(unloadListeners, function(v) {
+                if (v) {
+                    try{
+                        scope =  v[ADJ_SCOPE] ? (v[ADJ_SCOPE] === true ? v[OBJ] : v[ADJ_SCOPE]) :  win; 
+                        v[FN].call(scope, EU.getEvent(e), v[OBJ]);
+                    }catch(ex){}
+                }   
+            });     
+
+            unloadListeners = null;
+
+            if(listeners && (j = listeners.length)){                    
+                while(j){                        
+                    if((l = listeners[index = --j])){
+                        EU.removeListener(l[EL], l[TYPE], l[FN], index);
+                    }                        
+                }
+                //EU.clearCache();
+            }
+
+            doRemove(win, UNLOAD, EU._unload);
+        }            
+    };        
+    
+    // Initialize stuff.
+    pub.on = pub.addListener;
+    pub.un = pub.removeListener;
+    if (doc && doc.body) {
+        pub._load(true);
+    } else {
+        doAdd(win, "load", pub._load);
+    }
+    doAdd(win, UNLOAD, pub._unload);    
+    _tryPreloadAttach();
+    
+    return pub;
+}();