lpmp 1.0.0

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

@@ -0,0 +1,371 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+/*
+ * Portions of this file are based on pieces of Yahoo User Interface Library
+ * Copyright (c) 2007, Yahoo! Inc. All rights reserved.
+ * YUI licensed under the BSD License:
+ * http://developer.yahoo.net/yui/license.txt
+ */
+    Ext.lib.Ajax = function() {	    
+	    var activeX = ['MSXML2.XMLHTTP.3.0',
+			           'MSXML2.XMLHTTP',
+			           'Microsoft.XMLHTTP'],
+            CONTENTTYPE = 'Content-Type';
+			           
+		// private
+		function setHeader(o) {
+	        var conn = o.conn,
+	        	prop;
+	        
+	        function setTheHeaders(conn, headers){
+		     	for (prop in headers) {
+                    if (headers.hasOwnProperty(prop)) {
+                        conn.setRequestHeader(prop, headers[prop]);
+                    }
+                }   
+	        }		
+	        
+            if (pub.defaultHeaders) {
+	            setTheHeaders(conn, pub.defaultHeaders);
+            }
+
+            if (pub.headers) {
+				setTheHeaders(conn, pub.headers);
+                pub.headers = null;                
+            }
+        }    
+        
+        // private
+        function createExceptionObject(tId, callbackArg, isAbort, isTimeout) {	        
+            return {
+	            tId : tId,
+	            status : isAbort ? -1 : 0,
+	            statusText : isAbort ? 'transaction aborted' : 'communication failure',
+                    isAbort: true,
+                    isTimeout: true,
+	            argument : callbackArg
+            };
+        }  
+        
+        // private 
+        function initHeader(label, value) {         
+			(pub.headers = pub.headers || {})[label] = value;			            
+        }
+	    
+        // private
+        function createResponseObject(o, callbackArg) {
+            var headerObj = {},
+                headerStr,              
+                conn = o.conn,
+                t,
+                s;
+
+            try {
+                headerStr = o.conn.getAllResponseHeaders();   
+                Ext.each(headerStr.replace(/\r\n/g, '\n').split('\n'), function(v){
+                    t = v.indexOf(':');
+                    if(t >= 0){
+                        s = v.substr(0, t).toLowerCase();
+                        if(v.charAt(t + 1) == ' '){
+                            ++t;
+                        }
+                        headerObj[s] = v.substr(t + 1);
+                    }
+                });
+            } catch(e) {}
+                        
+            return {
+                tId : o.tId,
+                status : conn.status,
+                statusText : conn.statusText,
+                getResponseHeader : function(header){return headerObj[header.toLowerCase()];},
+                getAllResponseHeaders : function(){return headerStr},
+                responseText : conn.responseText,
+                responseXML : conn.responseXML,
+                argument : callbackArg
+            };
+        }
+        
+        // private
+        function releaseObject(o) {
+            o.conn = null;
+            o = null;
+        }        
+	    
+        // private
+        function handleTransactionResponse(o, callback, isAbort, isTimeout) {
+            if (!callback) {
+                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) || (Ext.isIE && httpStatus == 1223)) {
+                responseObject = 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 = createExceptionObject(o.tId, callback.argument, (isAbort ? isAbort : false), isTimeout);
+                        if (callback.failure) {
+                            if (!callback.scope) {
+                                callback.failure(responseObject);
+                            }
+                            else {
+                                callback.failure.apply(callback.scope, [responseObject]);
+                            }
+                        }
+                        break;
+                    default:
+                        responseObject = createResponseObject(o, callback.argument);
+                        if (callback.failure) {
+                            if (!callback.scope) {
+                                callback.failure(responseObject);
+                            }
+                            else {
+                                callback.failure.apply(callback.scope, [responseObject]);
+                            }
+                        }
+                }
+            }
+
+            releaseObject(o);
+            responseObject = null;
+        }  
+        
+        // private
+        function handleReadyState(o, callback){
+	    callback = callback || {};
+            var conn = o.conn,
+            	tId = o.tId,
+            	poll = pub.poll,
+		cbTimeout = callback.timeout || null;
+
+            if (cbTimeout) {
+                pub.timeout[tId] = setTimeout(function() {
+                    pub.abort(o, callback, true);
+                }, cbTimeout);
+            }
+
+            poll[tId] = setInterval(
+                function() {
+                    if (conn && conn.readyState == 4) {
+                        clearInterval(poll[tId]);
+                        poll[tId] = null;
+
+                        if (cbTimeout) {
+                            clearTimeout(pub.timeout[tId]);
+                            pub.timeout[tId] = null;
+                        }
+
+                        handleTransactionResponse(o, callback);
+                    }
+                },
+                pub.pollInterval);
+        }
+        
+        // private
+        function asyncRequest(method, uri, callback, postData) {
+            var o = getConnectionObject() || null;
+
+            if (o) {
+                o.conn.open(method, uri, true);
+
+                if (pub.useDefaultXhrHeader) {                    
+                	initHeader('X-Requested-With', pub.defaultXhrHeader);
+                }
+
+                if(postData && pub.useDefaultHeader && (!pub.headers || !pub.headers[CONTENTTYPE])){
+                    initHeader(CONTENTTYPE, pub.defaultPostHeader);
+                }
+
+                if (pub.defaultHeaders || pub.headers) {
+                    setHeader(o);
+                }
+
+                handleReadyState(o, callback);
+                o.conn.send(postData || null);
+            }
+            return o;
+        }
+        
+        // private
+        function getConnectionObject() {
+            var o;      	
+
+            try {
+                if (o = createXhrObject(pub.transactionId)) {
+                    pub.transactionId++;
+                }
+            } catch(e) {
+            } finally {
+                return o;
+            }
+        }
+	       
+        // private
+        function createXhrObject(transactionId) {
+            var http;
+            	
+            try {
+                http = new XMLHttpRequest();                
+            } catch(e) {
+                for (var i = 0; i < activeX.length; ++i) {	            
+                    try {
+                        http = new ActiveXObject(activeX[i]);                        
+                        break;
+                    } catch(e) {}
+                }
+            } finally {
+                return {conn : http, tId : transactionId};
+            }
+        }
+	         
+	    var pub = {
+	        request : function(method, uri, cb, data, options) {
+			    if(options){
+			        var me = this,		        
+			        	xmlData = options.xmlData,
+			        	jsonData = options.jsonData,
+                        hs;
+			        	
+			        Ext.applyIf(me, options);	        
+		            
+		            if(xmlData || jsonData){
+                        hs = me.headers;
+                        if(!hs || !hs[CONTENTTYPE]){
+			                initHeader(CONTENTTYPE, xmlData ? 'text/xml' : 'application/json');
+                        }
+			            data = xmlData || (Ext.isObject(jsonData) ? Ext.encode(jsonData) : jsonData);
+			        }
+			    }		    		    
+			    return asyncRequest(method || options.method || "POST", uri, cb, data);
+	        },
+	
+	        serializeForm : function(form) {
+		        var fElements = form.elements || (document.forms[form] || Ext.getDom(form)).elements,
+	            	hasSubmit = false,
+	            	encoder = encodeURIComponent,
+		        	element,
+	            	options, 
+	            	name, 
+	            	val,             	
+	            	data = '',
+	            	type;
+	            	
+		        Ext.each(fElements, function(element) {		            
+	                name = element.name;	             
+					type = element.type;
+					
+	                if (!element.disabled && name){
+		                if(/select-(one|multiple)/i.test(type)){			                
+				            Ext.each(element.options, function(opt) {
+					            if (opt.selected) {
+						            data += String.format("{0}={1}&", 						            					  
+						            					 encoder(name),						            					 
+						            					  (opt.hasAttribute ? opt.hasAttribute('value') : opt.getAttributeNode('value').specified) ? opt.value : opt.text);
+                                }								
+                            });
+		                } else if(!/file|undefined|reset|button/i.test(type)) {
+			                if(!(/radio|checkbox/i.test(type) && !element.checked) && !(type == 'submit' && hasSubmit)){
+                                    
+                                data += encoder(name) + '=' + encoder(element.value) + '&';                     
+                                hasSubmit = /submit/i.test(type);    
+                            } 		                
+		                } 
+	                }
+	            });            
+	            return data.substr(0, data.length - 1);
+	        },
+	        
+	        useDefaultHeader : true,
+	        defaultPostHeader : 'application/x-www-form-urlencoded; charset=UTF-8',
+	        useDefaultXhrHeader : true,
+	        defaultXhrHeader : 'XMLHttpRequest',        
+	        poll : {},
+	        timeout : {},
+	        pollInterval : 50,
+	        transactionId : 0,
+	        
+//	This is never called - Is it worth exposing this?  		        
+// 	        setProgId : function(id) {
+// 	            activeX.unshift(id);
+// 	        },
+
+//	This is never called - Is it worth exposing this?  	
+// 	        setDefaultPostHeader : function(b) {
+// 	            this.useDefaultHeader = b;
+// 	        },
+	        
+//	This is never called - Is it worth exposing this?  	
+// 	        setDefaultXhrHeader : function(b) {
+// 	            this.useDefaultXhrHeader = b;
+// 	        },
+
+//	This is never called - Is it worth exposing this?        	
+// 	        setPollingInterval : function(i) {
+// 	            if (typeof i == 'number' && isFinite(i)) {
+// 	                this.pollInterval = i;
+// 	            }
+// 	        },
+	        
+//	This is never called - Is it worth exposing this?
+// 	        resetDefaultHeaders : function() {
+// 	            this.defaultHeaders = null;
+// 	        },
+	
+	        abort : function(o, callback, isTimeout) {
+		        var me = this,
+		        	tId = o.tId,
+		        	isAbort = false;
+		        
+	            if (me.isCallInProgress(o)) {
+	                o.conn.abort();
+	                clearInterval(me.poll[tId]);
+	               	me.poll[tId] = null;
+	                if (isTimeout) {
+	                    me.timeout[tId] = null;
+	                }
+					
+	                handleTransactionResponse(o, callback, (isAbort = true), isTimeout);                
+	            }
+	            return isAbort;
+	        },
+	
+	        isCallInProgress : function(o) {
+	            // if there is a connection and readyState is not 0 or 4
+	            return o.conn && !{0:true,4:true}[o.conn.readyState];	        
+	        }
+	    };
+	    return pub;
+    }();

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

@@ -0,0 +1,301 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+// Easing functions
+(function(){
+	// shortcuts to aid compression
+	var abs = Math.abs,
+	 	pi = Math.PI,
+	 	asin = Math.asin,
+	 	pow = Math.pow,
+	 	sin = Math.sin,
+		EXTLIB = Ext.lib;
+	 	
+    Ext.apply(EXTLIB.Easing, {
+        
+        easeBoth: function (t, b, c, d) {
+	        return ((t /= d / 2) < 1)  ?  c / 2 * t * t + b  :  -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) {
+            return ((t /= d / 2) < 1)  ?  c / 2 * t * t * t * t + b  :  -c / 2 * ((t -= 2) * t * t * t - 2) + b;
+        },
+
+        elasticIn: function (t, b, c, d, a, p) {
+	        if (t == 0 || (t /= d) == 1) {
+                return t == 0 ? b : b + c;
+            }	            
+            p = p || (d * .3);	            
+
+			var s;
+			if (a >= abs(c)) {
+				s = p / (2 * pi) * asin(c / a);
+			} else {
+				a = c;
+				s = p / 4;
+			}
+	
+            return -(a * pow(2, 10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p)) + b;
+            	      
+        }, 	
+	
+		elasticOut: function (t, b, c, d, a, p) {
+	        if (t == 0 || (t /= d) == 1) {
+                return t == 0 ? b : b + c;
+            }	            
+            p = p || (d * .3);	            
+
+			var s;
+			if (a >= abs(c)) {
+				s = p / (2 * pi) * asin(c / a);
+			} else {
+				a = c;
+				s = p / 4;
+			}
+	
+            return a * pow(2, -10 * t) * sin((t * d - s) * (2 * pi) / p) + c + b;	 
+        }, 	
+	
+        elasticBoth: function (t, b, c, d, a, p) {
+            if (t == 0 || (t /= d / 2) == 2) {
+                return t == 0 ? b : b + c;
+            }		         	
+	            
+            p = p || (d * (.3 * 1.5)); 	            
+
+            var s;
+            if (a >= abs(c)) {
+	            s = p / (2 * pi) * asin(c / a);
+            } else {
+	            a = c;
+                s = p / 4;
+            }
+
+            return t < 1 ?
+            	   	-.5 * (a * pow(2, 10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p)) + b :
+                    a * pow(2, -10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p) * .5 + c + b;
+        },
+
+        backIn: function (t, b, c, d, s) {
+            s = s ||  1.70158; 	            
+            return c * (t /= d) * t * ((s + 1) * t - s) + b;
+        },
+
+
+        backOut: function (t, b, c, d, s) {
+            if (!s) {
+                s = 1.70158;
+            }
+            return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
+        },
+
+
+        backBoth: function (t, b, c, d, s) {
+            s = s || 1.70158; 	            
+
+            return ((t /= d / 2 ) < 1) ?
+                    c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b : 	            
+            		c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
+        },
+
+
+        bounceIn: function (t, b, c, d) {
+            return c - EXTLIB.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) {
+            return (t < d / 2) ?
+                   EXTLIB.Easing.bounceIn(t * 2, 0, c, d) * .5 + b : 
+            	   EXTLIB.Easing.bounceOut(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
+        }
+    });
+})();
+
+(function() {
+    var EXTLIB = Ext.lib;
+	// Color Animation
+	EXTLIB.Anim.color = function(el, args, duration, easing, cb, scope) {
+	    return EXTLIB.Anim.run(el, args, duration, easing, cb, scope, EXTLIB.ColorAnim);
+	}
+	
+    EXTLIB.ColorAnim = function(el, attributes, duration, method) {
+        EXTLIB.ColorAnim.superclass.constructor.call(this, el, attributes, duration, method);
+    };
+
+    Ext.extend(EXTLIB.ColorAnim, EXTLIB.AnimBase);
+
+    var superclass = EXTLIB.ColorAnim.superclass,
+    	colorRE = /color$/i,
+    	transparentRE = /^transparent|rgba\(0, 0, 0, 0\)$/,
+        rgbRE = /^rgb\(([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\)$/i,
+        hexRE= /^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i,
+        hex3RE = /^#?([0-9A-F]{1})([0-9A-F]{1})([0-9A-F]{1})$/i,
+        isset = function(v){
+            return typeof v !== 'undefined';
+        }
+         	
+   	// private	
+    function parseColor(s) {	
+        var pi = parseInt,
+            base,
+            out = null,
+            c;
+        
+	    if (s.length == 3) {
+            return s;
+        }
+        
+        Ext.each([hexRE, rgbRE, hex3RE], function(re, idx){
+            base = (idx % 2 == 0) ? 16 : 10;
+            c = re.exec(s);
+            if(c && c.length == 4){
+                out = [pi(c[1], base), pi(c[2], base), pi(c[3], base)];
+                return false;
+            }
+        });
+        return out;
+    }	
+
+    Ext.apply(EXTLIB.ColorAnim.prototype, {
+        getAttr : function(attr) {
+            var me = this,
+                el = me.el,
+                val;                
+            if(colorRE.test(attr)){
+                while(el && transparentRE.test(val = Ext.fly(el).getStyle(attr))){
+                    el = el.parentNode;
+                    val = "fff";
+                }
+            }else{
+                val = superclass.getAttr.call(me, attr);
+            }
+            return val;
+        },
+
+        doMethod : function(attr, start, end) {
+            var me = this,
+            	val,
+            	floor = Math.floor;            
+
+            if(colorRE.test(attr)){
+                val = [];
+             
+	            Ext.each(start, function(v, i) {
+                    val[i] = superclass.doMethod.call(me, attr, v, end[i]);
+                });
+
+                val = 'rgb(' + floor(val[0]) + ',' + floor(val[1]) + ',' + floor(val[2]) + ')';
+            }else{
+                val = superclass.doMethod.call(me, attr, start, end);
+            }
+            return val;
+        },
+
+        setRunAttr : function(attr) {
+            var me = this,
+                a = me.attributes[attr],
+                to = a.to,
+                by = a.by,
+                ra;
+                
+            superclass.setRunAttr.call(me, attr);
+            ra = me.runAttrs[attr];
+            if(colorRE.test(attr)){
+                var start = parseColor(ra.start),
+                    end = parseColor(ra.end);
+
+                if(!isset(to) && isset(by)){
+                    end = parseColor(by);
+                    Ext.each(start, function(item, i){
+                        end[i] = item + end[i];
+                    });
+                }
+                ra.start = start;
+                ra.end = end;
+            }
+        }
+	});
+})();	
+
+	
+(function() {
+	    // Scroll Animation	
+    var EXTLIB = Ext.lib;
+	EXTLIB.Anim.scroll = function(el, args, duration, easing, cb, scope) {	        
+	    return EXTLIB.Anim.run(el, args, duration, easing, cb, scope, EXTLIB.Scroll);
+	}
+	
+    EXTLIB.Scroll = function(el, attributes, duration, method) {
+        if(el){
+            EXTLIB.Scroll.superclass.constructor.call(this, el, attributes, duration, method);
+        }
+    };
+
+    Ext.extend(EXTLIB.Scroll, EXTLIB.ColorAnim);
+
+    var superclass = EXTLIB.Scroll.superclass,
+    	SCROLL = 'scroll';
+
+    Ext.apply(EXTLIB.Scroll.prototype, {
+
+        doMethod : function(attr, start, end) {
+            var val,
+            	me = this,
+            	curFrame = me.curFrame,
+            	totalFrames = me.totalFrames;
+
+            if(attr == SCROLL){
+                val = [me.method(curFrame, start[0], end[0] - start[0], totalFrames),
+                       me.method(curFrame, start[1], end[1] - start[1], totalFrames)];
+            }else{
+                val = superclass.doMethod.call(me, attr, start, end);
+            }
+            return val;
+        },
+
+        getAttr : function(attr) {
+            var me = this;
+
+            if (attr == SCROLL) {
+                return [me.el.scrollLeft, me.el.scrollTop];
+            }else{
+                return superclass.getAttr.call(me, attr);
+            }
+        },
+
+        setAttr : function(attr, val, unit) {
+            var me = this;
+
+            if(attr == SCROLL){
+                me.el.scrollLeft = val[0];
+                me.el.scrollTop = val[1];
+            }else{
+                superclass.setAttr.call(me, attr, val, unit);
+            }
+        }
+    });
+})();