lpmp 1.0.0

data/public/ext-3.0.0/src/core/CompositeElementLite-more.js

@@ -0,0 +1,102 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+/**
+ * @class Ext.CompositeElementLite
+ */
+Ext.apply(Ext.CompositeElementLite.prototype, {	
+	addElements : function(els, root){
+        if(!els){
+            return this;
+        }
+        if(typeof els == "string"){
+            els = Ext.Element.selectorFunction(els, root);
+        }
+        var yels = this.elements;        
+	    Ext.each(els, function(e) {
+        	yels.push(Ext.get(e));
+        });
+        return this;
+    },
+    
+    /**
+    * Clears this composite and adds the elements returned by the passed selector.
+    * @param {String/Array} els A string CSS selector, an array of elements or an element
+    * @return {CompositeElement} this
+    */
+    fill : function(els){
+        this.elements = [];
+        this.add(els);
+        return this;
+    },
+    
+    /**
+     * Returns the first Element
+     * @return {Ext.Element}
+     */
+    first : function(){
+        return this.item(0);
+    },   
+    
+    /**
+     * Returns the last Element
+     * @return {Ext.Element}
+     */
+    last : function(){
+        return this.item(this.getCount()-1);
+    },
+    
+    /**
+     * Returns true if this composite contains the passed element
+     * @param el {Mixed} The id of an element, or an Ext.Element, or an HtmlElement to find within the composite collection.
+     * @return Boolean
+     */
+    contains : function(el){
+        return this.indexOf(el) != -1;
+    },
+
+    /**
+    * Filters this composite to only elements that match the passed selector.
+    * @param {String} selector A string CSS selector
+    * @return {CompositeElement} this
+    */
+    filter : function(selector){
+        var els = [];
+        this.each(function(el){
+            if(el.is(selector)){
+                els[els.length] = el.dom;
+            }
+        });
+        this.fill(els);
+        return this;
+    },
+    
+    /**
+    * Removes the specified element(s).
+    * @param {Mixed} el The id of an element, the Element itself, the index of the element in this composite
+    * or an array of any of those.
+    * @param {Boolean} removeDom (optional) True to also remove the element from the document
+    * @return {CompositeElement} this
+    */
+    removeElement : function(keys, removeDom){
+        var me = this,
+	        els = this.elements,	    
+	    	el;	    	
+	    Ext.each(keys, function(val){
+		    if ((el = (els[val] || els[val = me.indexOf(val)]))) {
+		    	if(removeDom){
+                    if(el.dom){
+                        el.remove();
+                    }else{
+                        Ext.removeNode(el);
+                    }
+                }
+		    	els.splice(val, 1);		    	
+			}
+	    });
+        return this;
+    }    
+});

data/public/ext-3.0.0/src/core/DomHelper-more.js

@@ -0,0 +1,179 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+/**
+ * @class Ext.DomHelper
+ */
+Ext.apply(Ext.DomHelper,
+function(){
+	var pub,
+		afterbegin = 'afterbegin',
+    	afterend = 'afterend',
+    	beforebegin = 'beforebegin',
+    	beforeend = 'beforeend';
+
+	// private
+    function doInsert(el, o, returnElement, pos, sibling, append){
+        el = Ext.getDom(el);
+        var newNode;
+        if (pub.useDom) {
+            newNode = createDom(o, null);
+            if (append) {
+	            el.appendChild(newNode);
+            } else {
+	        	(sibling == 'firstChild' ? el : el.parentNode).insertBefore(newNode, el[sibling] || el);
+            }
+        } else {
+            newNode = Ext.DomHelper.insertHtml(pos, el, Ext.DomHelper.createHtml(o));
+        }
+        return returnElement ? Ext.get(newNode, true) : newNode;
+    }
+
+	// build as dom
+    /** @ignore */
+    function createDom(o, parentNode){
+        var el,
+        	doc = document,
+        	useSet,
+        	attr,
+        	val,
+        	cn;
+
+        if (Ext.isArray(o)) {                       // Allow Arrays of siblings to be inserted
+            el = doc.createDocumentFragment(); // in one shot using a DocumentFragment
+	        Ext.each(o, function(v) {
+                createDom(v, el);
+            });
+        } else if (Ext.isString(o)) {         // Allow a string as a child spec.
+            el = doc.createTextNode(o);
+        } else {
+            el = doc.createElement( o.tag || 'div' );
+            useSet = !!el.setAttribute; // In IE some elements don't have setAttribute
+            Ext.iterate(o, function(attr, val){
+                if(!/tag|children|cn|html|style/.test(attr)){
+	                if(attr == 'cls'){
+	                    el.className = val;
+	                }else{
+                        if(useSet){
+                            el.setAttribute(attr, val);
+                        }else{
+                            el[attr] = val;
+                        }
+	                }
+                }
+            });
+            pub.applyStyles(el, o.style);
+
+            if ((cn = o.children || o.cn)) {
+                createDom(cn, el);
+            } else if (o.html) {
+                el.innerHTML = o.html;
+            }
+        }
+        if(parentNode){
+           parentNode.appendChild(el);
+        }
+        return el;
+    }
+
+	pub = {
+		/**
+	     * Creates a new Ext.Template from the DOM object spec.
+	     * @param {Object} o The DOM object spec (and children)
+	     * @return {Ext.Template} The new template
+	     */
+	    createTemplate : function(o){
+	        var html = Ext.DomHelper.createHtml(o);
+	        return new Ext.Template(html);
+	    },
+
+		/** True to force the use of DOM instead of html fragments @type Boolean */
+	    useDom : false,
+
+	    /**
+	     * Applies a style specification to an element.
+	     * @param {String/HTMLElement} el The element to apply styles to
+	     * @param {String/Object/Function} styles A style specification string e.g. 'width:100px', or object in the form {width:'100px'}, or
+	     * a function which returns such a specification.
+	     */
+	    applyStyles : function(el, styles){
+		    if(styles){
+				var i = 0,
+	    			len,
+	    			style;
+
+	    		el = Ext.fly(el);
+				if(Ext.isFunction(styles)){
+   					styles = styles.call();
+				}
+				if(Ext.isString(styles)){
+					styles = styles.trim().split(/\s*(?::|;)\s*/);
+					for(len = styles.length; i < len;){
+						el.setStyle(styles[i++], styles[i++]);
+					}
+				}else if (Ext.isObject(styles)){
+					el.setStyle(styles);
+				}
+			}
+	    },
+
+	    /**
+	     * Creates new DOM element(s) and inserts them before el.
+	     * @param {Mixed} el The context element
+	     * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
+	     * @param {Boolean} returnElement (optional) true to return a Ext.Element
+	     * @return {HTMLElement/Ext.Element} The new node
+         * @hide (repeat)
+	     */
+	    insertBefore : function(el, o, returnElement){
+	        return doInsert(el, o, returnElement, beforebegin);
+	    },
+
+	    /**
+	     * Creates new DOM element(s) and inserts them after el.
+	     * @param {Mixed} el The context element
+	     * @param {Object} o The DOM object spec (and children)
+	     * @param {Boolean} returnElement (optional) true to return a Ext.Element
+	     * @return {HTMLElement/Ext.Element} The new node
+         * @hide (repeat)
+	     */
+	    insertAfter : function(el, o, returnElement){
+	        return doInsert(el, o, returnElement, afterend, 'nextSibling');
+	    },
+
+	    /**
+	     * Creates new DOM element(s) and inserts them as the first child of el.
+	     * @param {Mixed} el The context element
+	     * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
+	     * @param {Boolean} returnElement (optional) true to return a Ext.Element
+	     * @return {HTMLElement/Ext.Element} The new node
+         * @hide (repeat)
+	     */
+	    insertFirst : function(el, o, returnElement){
+	        return doInsert(el, o, returnElement, afterbegin, 'firstChild');
+	    },
+
+	    /**
+	     * Creates new DOM element(s) and appends them to el.
+	     * @param {Mixed} el The context element
+	     * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
+	     * @param {Boolean} returnElement (optional) true to return a Ext.Element
+	     * @return {HTMLElement/Ext.Element} The new node
+         * @hide (repeat)
+	     */
+	    append: function(el, o, returnElement){
+            return doInsert(el, o, returnElement, beforeend, '', true);
+        },
+
+	    /**
+	     * Creates new DOM element(s) without inserting them to the document.
+	     * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
+	     * @return {HTMLElement} The new uninserted node
+	     */
+        createDom: createDom
+	};
+	return pub;
+}());

data/public/ext-3.0.0/src/core/Element-more.js

@@ -0,0 +1,192 @@
+/*!
+ * Ext JS Library 3.0.0
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+/**
+ * @class Ext.Element
+ */
+Ext.Element.addMethods({    
+    /**
+     * Stops the specified event(s) from bubbling and optionally prevents the default action
+     * @param {String/Array} eventName an event / array of events to stop from bubbling
+     * @param {Boolean} preventDefault (optional) true to prevent the default action too
+     * @return {Ext.Element} this
+     */
+    swallowEvent : function(eventName, preventDefault){
+	    var me = this;
+        function fn(e){
+            e.stopPropagation();
+            if(preventDefault){
+                e.preventDefault();
+            }
+        }
+        if(Ext.isArray(eventName)){            
+	        Ext.each(eventName, function(e) {
+                 me.on(e, fn);
+            });
+            return me;
+        }
+        me.on(eventName, fn);
+        return me;
+    },
+    
+    /**
+     * Create an event handler on this element such that when the event fires and is handled by this element,
+     * it will be relayed to another object (i.e., fired again as if it originated from that object instead).
+     * @param {String} eventName The type of event to relay
+     * @param {Object} object Any object that extends {@link Ext.util.Observable} that will provide the context
+     * for firing the relayed event
+     */
+    relayEvent : function(eventName, observable){
+        this.on(eventName, function(e){
+            observable.fireEvent(eventName, e);
+        });
+    },
+    
+	/**
+     * Removes worthless text nodes
+     * @param {Boolean} forceReclean (optional) By default the element
+     * keeps track if it has been cleaned already so
+     * you can call this over and over. However, if you update the element and
+     * need to force a reclean, you can pass true.
+     */
+    clean : function(forceReclean){
+        var me = this, 
+            dom = me.dom,
+        	n = dom.firstChild, 
+        	ni = -1;
+        	
+	    if(Ext.Element.data(dom, 'isCleaned') && forceReclean !== true){
+            return me;
+        }      
+        	
+ 	    while(n){
+ 	        var nx = n.nextSibling;
+            if(n.nodeType == 3 && !/\S/.test(n.nodeValue)){
+                dom.removeChild(n);
+            }else{
+                n.nodeIndex = ++ni;
+            }
+ 	        n = nx;
+ 	    }
+        Ext.Element.data(dom, 'isCleaned', true);
+ 	    return me;
+ 	},
+    
+    /**
+     * Direct access to the Updater {@link Ext.Updater#update} method. The method takes the same object
+     * parameter as {@link Ext.Updater#update}
+     * @return {Ext.Element} this
+     */
+    load : function(){
+        var um = this.getUpdater();
+        um.update.apply(um, arguments);
+        return this;
+    },
+
+    /**
+    * Gets this element's {@link Ext.Updater Updater}
+    * @return {Ext.Updater} The Updater
+    */
+    getUpdater : function(){
+        return this.updateManager || (this.updateManager = new Ext.Updater(this));
+    },
+    
+	/**
+    * Update the innerHTML of this element, optionally searching for and processing scripts
+    * @param {String} html The new HTML
+    * @param {Boolean} loadScripts (optional) True to look for and process scripts (defaults to false)
+    * @param {Function} callback (optional) For async script loading you can be notified when the update completes
+    * @return {Ext.Element} this
+     */
+    update : function(html, loadScripts, callback){
+        html = html || "";
+	    
+        if(loadScripts !== true){
+            this.dom.innerHTML = html;
+            if(Ext.isFunction(callback)){
+                callback();
+            }
+            return this;
+        }
+        
+        var id = Ext.id(),
+        	dom = this.dom;
+
+        html += '<span id="' + id + '"></span>';
+
+        Ext.lib.Event.onAvailable(id, function(){
+            var DOC = document,
+                hd = DOC.getElementsByTagName("head")[0],
+            	re = /(?:<script([^>]*)?>)((\n|\r|.)*?)(?:<\/script>)/ig,
+            	srcRe = /\ssrc=([\'\"])(.*?)\1/i,
+            	typeRe = /\stype=([\'\"])(.*?)\1/i,
+            	match,
+            	attrs,
+            	srcMatch,
+            	typeMatch,
+            	el,
+            	s;
+
+            while((match = re.exec(html))){
+                attrs = match[1];
+                srcMatch = attrs ? attrs.match(srcRe) : false;
+                if(srcMatch && srcMatch[2]){
+                   s = DOC.createElement("script");
+                   s.src = srcMatch[2];
+                   typeMatch = attrs.match(typeRe);
+                   if(typeMatch && typeMatch[2]){
+                       s.type = typeMatch[2];
+                   }
+                   hd.appendChild(s);
+                }else if(match[2] && match[2].length > 0){
+                    if(window.execScript) {
+                       window.execScript(match[2]);
+                    } else {
+                       window.eval(match[2]);
+                    }
+                }
+            }
+            el = DOC.getElementById(id);
+            if(el){Ext.removeNode(el);}
+            if(Ext.isFunction(callback)){
+                callback();
+            }
+        });
+        dom.innerHTML = html.replace(/(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig, "");
+        return this;
+    },
+    
+    /**
+     * Creates a proxy element of this element
+     * @param {String/Object} config The class name of the proxy element or a DomHelper config object
+     * @param {String/HTMLElement} renderTo (optional) The element or element id to render the proxy to (defaults to document.body)
+     * @param {Boolean} matchBox (optional) True to align and size the proxy to this element now (defaults to false)
+     * @return {Ext.Element} The new proxy element
+     */
+    createProxy : function(config, renderTo, matchBox){
+        config = Ext.isObject(config) ? config : {tag : "div", cls: config};
+
+        var me = this,
+        	proxy = renderTo ? Ext.DomHelper.append(renderTo, config, true) :
+        					   Ext.DomHelper.insertBefore(me.dom, config, true);        
+        
+        if(matchBox && me.setBox && me.getBox){ // check to make sure Element.position.js is loaded
+           proxy.setBox(me.getBox());
+        }
+        return proxy;
+    }
+});
+
+Ext.Element.prototype.getUpdateManager = Ext.Element.prototype.getUpdater;
+
+// private
+Ext.Element.uncache = function(el){
+    for(var i = 0, a = arguments, len = a.length; i < len; i++) {
+        if(a[i]){
+            delete Ext.Element.cache[a[i].id || a[i]];
+        }
+    }
+};