envjs19 0.3.8.20101029121421

data/src/html/frame.js

@@ -0,0 +1,89 @@
+$debug("Defining HTMLFrameElement");
+/* 
+* HTMLFrameElement - DOM Level 2
+*/
+var HTMLFrameElement = function(ownerDocument) {
+    this.HTMLElement = HTMLElement;
+    this.HTMLElement(ownerDocument);
+};
+HTMLFrameElement.prototype = new HTMLElement;
+__extend__(HTMLFrameElement.prototype, {
+    get frameBorder(){
+        return this.getAttribute('border')||"";
+    },
+    set frameBorder(value){
+        this.setAttribute('border', value);
+    },
+    get longDesc(){
+        return this.getAttribute('longdesc')||"";
+    },
+    set longDesc(value){
+        this.setAttribute('longdesc', value);
+    },
+    get marginHeight(){
+        return this.getAttribute('marginheight')||"";
+    },
+    set marginHeight(value){
+        this.setAttribute('marginheight', value);
+    },
+    get marginWidth(){
+        return this.getAttribute('marginwidth')||"";
+    },
+    set marginWidth(value){
+        this.setAttribute('marginwidth', value);
+    },
+    get name(){
+        return this.getAttribute('name')||"";
+    },
+    set name(value){
+        this.setAttribute('name', value);
+    },
+    get noResize(){
+        return this.getAttribute('noresize')||"";
+    },
+    set noResize(value){
+        this.setAttribute('noresize', value);
+    },
+    get scrolling(){
+        return this.getAttribute('scrolling')||"";
+    },
+    set scrolling(value){
+        this.setAttribute('scrolling', value);
+    },
+    get src(){
+        return this.getAttribute('src')||"";
+    },
+    set src(value){
+        this.setAttribute('src', value);
+
+        if (value && value.length > 0){
+            var save = $master.first_script_window;
+            try {
+              var $env = this.ownerDocument._parentWindow.$envx;
+              var $inner = this.ownerDocument._parentWindow["$inner"];
+              $master.first_script_window = $inner;
+              $env.loadFrame(this, $env.location(value));
+            } finally {
+              $master.first_script_window = save;
+            }
+
+            
+            var event = this.ownerDocument.createEvent();
+            event.initEvent("load");
+            this.dispatchEvent( event, false );
+        }
+    },
+    get contentDocument(){
+        if (!this._content)
+            return null;
+        return this._content.document;
+    },
+    get contentWindow(){
+        return this._content;
+    },
+    onload: function(event){
+        return __eval__(this.getAttribute('onload')||'', this)
+    }
+});
+
+// $w.HTMLFrameElement = HTMLFrameElement;

data/src/html/frameset.js

@@ -0,0 +1,25 @@
+$debug("Defining HTMLFrameSetElement");
+/* 
+* HTMLFrameSetElement - DOM Level 2
+*/
+var HTMLFrameSetElement = function(ownerDocument) {
+    this.HTMLElement = HTMLElement;
+    this.HTMLElement(ownerDocument);
+};
+HTMLFrameSetElement.prototype = new HTMLElement;
+__extend__(HTMLFrameSetElement.prototype, {
+    get cols(){
+        return this.getAttribute('cols');
+    },
+    set cols(value){
+        this.setAttribute('cols', value);
+    },
+    get rows(){
+        return this.getAttribute('rows');
+    },
+    set rows(value){
+        this.setAttribute('rows', value);
+    }
+});
+
+// $w.HTMLFrameSetElement = HTMLFrameSetElement;	

data/src/html/head.js

@@ -0,0 +1,44 @@
+$debug("Defining HTMLHeadElement");
+/* 
+* HTMLHeadElement - DOM Level 2
+*/
+var HTMLHeadElement = function(ownerDocument) {
+    this.HTMLElement = HTMLElement;
+    this.HTMLElement(ownerDocument);
+};
+HTMLHeadElement.prototype = new HTMLElement;
+__extend__(HTMLHeadElement.prototype, {
+    get profile(){
+        return this.getAttribute('profile');
+    },
+    set profile(value){
+        this.setAttribute('profile', value);
+    },
+    //we override this so we can apply browser behavior specific to head children
+    //like loading scripts
+    appendChild : function(newChild) {
+        var newChild = HTMLElement.prototype.appendChild.apply(this,[newChild]);
+        //__evalScript__(newChild);
+        return newChild;
+    },
+    insertBefore : function(newChild, refChild) {
+        var newChild = HTMLElement.prototype.insertBefore.apply(this,[newChild]);
+        //__evalScript__(newChild);
+        return newChild;
+    }
+});
+
+var __evalScript__ = function(newChild){
+    //check to see if this is a script element and apply a script loading strategy
+    //the check against the ownerDocument isnt really enough to support frames in
+    // the long run, but for now it's ok
+    if(newChild.nodeType == DOMNode.ELEMENT_NODE && 
+        newChild.ownerDocument == window.document ){
+        if(newChild.nodeName.toUpperCase() == "SCRIPT"){
+            $debug("loading script via policy. ");
+            $policy.loadScript(newChild);
+        }
+    }
+};
+
+// $w.HTMLHeadElement = HTMLHeadElement;

data/src/html/htmlparser.js

@@ -0,0 +1,340 @@
+/*
+*	parser.js
+*/
+/*
+ * HTML Parser By John Resig (ejohn.org)
+ * Original code by Erik Arvidsson, Mozilla Public License
+ * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
+ *
+ * // Use like so:
+ * HTMLParser(htmlString, {
+ *     start: function(tag, attrs, unary) {},
+ *     end: function(tag) {},
+ *     chars: function(text) {},
+ *     comment: function(text) {}
+ * });
+ *
+ * // or to get an XML string:
+ * HTMLtoXML(htmlString);
+ *
+ * // or to get an XML DOM Document
+ * HTMLtoDOM(htmlString);
+ *
+ * // or to inject into an existing document/DOM node
+ * HTMLtoDOM(htmlString, document);
+ * HTMLtoDOM(htmlString, document.body);
+ *
+ */
+ var html2dom, html2xml;
+
+(function(){
+
+	// Regular Expressions for parsing tags and attributes
+	var startTag = /^<([\w\:\-]+)((?:\s+[\w\:\-]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,
+        endTag = /^<\/([\w\:\-]+)[^>]*>/,
+        attr = /([\w\:\-]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g; 	
+	// Empty Elements - HTML 4.01
+	var empty = makeMap("area,base,basefont,br,col,frame,hr,img,input,isindex,link,meta,param,embed");
+
+	// Block Elements - HTML 4.01
+	var block = makeMap("address,applet,blockquote,button,center,dd,del,dir,div,dl,dt,fieldset,form,frameset,hr,iframe,ins,isindex,li,map,menu,noframes,noscript,object,ol,p,pre,script,table,tbody,td,tfoot,th,thead,tr,ul");
+
+	// Inline Elements - HTML 4.01
+	var inline = makeMap("a,abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,textarea,tt,u,var");
+
+	// Elements that you can, intentionally, leave open
+	// (and which close themselves)
+	var closeSelf = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr");
+
+	// Attributes that have their values filled in disabled="disabled"
+	var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected");
+
+	// Special Elements (can contain anything)
+	var special = makeMap("script,style");
+
+	var HTMLParser  = function( html, handler ) {
+		var index, chars, match, stack = [], last = html;
+		stack.last = function(){
+			return this[ this.length - 1 ];
+		};
+
+		while ( html ) {
+		    //$log("HTMLParser: chunking... ");
+			chars = true;
+
+			// Make sure we're not in a script or style element
+			if ( !stack.last() || !special[ stack.last() ] ) {
+            
+		        //$log("HTMLParser: ... ");
+				// Comment
+				if ( html.indexOf("<!--") === 0 ) {
+		            //$log("HTMLParser: comment ");
+					index = html.indexOf("-->");
+	
+					if ( index >= 0 ) {
+						if ( handler.comment )
+							handler.comment( html.substring( 4, index ) );
+						html = html.substring( index + 3 );
+						chars = false;
+					}
+	
+				// end tag
+				} else if ( html.indexOf("</") === 0 ) {
+		            //$log("HTMLParser: endtag ");
+					match = html.match( endTag );
+	
+					if ( match ) {
+		                //$log("HTMLParser: endtag match : "+match[0]);
+						html = html.substring( match[0].length );
+						match[0].replace( endTag, parseEndTag );
+						chars = false;
+					}
+	
+				// start tag
+				} else if ( html.indexOf("<") === 0 ) {
+		            //$log("HTMLParser: starttag ");
+					match = html.match( startTag );
+	
+					if ( match ) {
+		                //$log("HTMLParser: starttag match : "+match[0]);
+						html = html.substring( match[0].length );
+						match[0].replace( startTag, parseStartTag );
+						chars = false;
+					}
+				}
+
+				if ( chars ) {
+		            //$log("HTMLParser: other ");
+					index = html.indexOf("<");
+					var text = index < 0 ? html : html.substring( 0, index );
+					html = index < 0 ? "" : html.substring( index );
+					if ( handler.chars ){
+		                //$log("HTMLParser: chars " + text);
+					    handler.chars( text );
+				    }
+				}
+			} else {
+		        //$log("HTMLParser: special ");
+				html = html.replace(new RegExp("(.*)<\/" + stack.last() + "[^>]*>"), function(all, text){
+					text = text.replace(/<!--(.*?)-->/g, "$1").
+						replace(/<!\[CDATA\[(.*?)]]>/g, "$1");
+					if ( handler.chars ){
+		                //$log("HTMLParser: special chars " + text);
+					    handler.chars( text );
+				    }
+					return "";
+				});
+				parseEndTag( "", stack.last() );
+			}
+			if ( html == last ){throw "Parse Error: " + html;}
+			last = html;
+		}
+		
+		// Clean up any remaining tags
+		parseEndTag();
+
+		function parseStartTag( tag, tagName, rest, unary ) {
+			if ( block[ tagName ] ) {
+				while ( stack.last() && inline[ stack.last() ] ) {
+					parseEndTag( "", stack.last() );
+				}
+			}
+
+			if ( closeSelf[ tagName ] && stack.last() == tagName ) {
+				parseEndTag( "", tagName );
+			}
+
+			unary = empty[ tagName ] || !!unary;
+
+			if ( !unary )
+				stack.push( tagName );
+			
+			if ( handler.start ) {
+				var attrs = [];
+	
+				rest.replace(attr, function(match, name) {
+					var value = arguments[2] ? arguments[2] :
+						arguments[3] ? arguments[3] :
+						arguments[4] ? arguments[4] :
+						fillAttrs[name] ? name : "";
+					
+					attrs.push({
+						name: name,
+						value: value,
+						escaped: value.replace(/(^|[^\\])"/g, '$1\\\"') //"
+					});
+				});
+	
+				if ( handler.start ){
+				    //$log("unary ? : "+unary);
+					handler.start( tagName, attrs, unary );
+				}
+			}
+		}
+
+		function parseEndTag( tag, tagName ) {
+		  var pos;
+			// If no tag name is provided, clean shop
+			if ( !tagName ){
+				pos = 0;
+			}else{
+			// Find the closest opened tag of the same type
+				for ( pos = stack.length - 1; pos >= 0; pos-- ){
+					//$log("parseEndTag : "+stack[ pos ] );
+					if ( stack[ pos ] == tagName ){ 
+					    break; 
+				    }
+				}
+            }
+			if ( pos >= 0 ) {
+				// Close all the open elements, up the stack
+				for ( var i = stack.length - 1; i >= pos; i-- ){
+                    if ( handler.end ){
+					    //$log("end : "+stack[ i ] );
+                        handler.end( stack[ i ] );
+                    }
+				}
+				// Remove the open elements from the stack
+				//$log("setting stack length : " + stack.length + " -> " +pos );
+				stack.length = pos;
+			}
+		}
+	};
+	
+	html2xml = function( html ) {
+		var results = "";
+		
+		HTMLParser(html, {
+			start: function( tag, attrs, unary ) {
+				results += "<" + tag;
+		
+				for ( var i = 0; i < attrs.length; i++ )
+					results += " " + attrs[i].name + '="' + attrs[i].escaped + '"';
+		
+				results += (unary ? "/" : "") + ">";
+			},
+			end: function( tag ) {
+				results += "</" + tag + ">";
+			},
+			chars: function( text ) {
+				results += text;
+			},
+			comment: function( text ) {
+				results += "<!--" + text + "-->";
+			}
+		});
+		
+		return results;
+	};
+	
+	html2dom = function( html, doc ) {
+		// There can be only one of these elements
+		var one = makeMap("html,head,body,title");
+		
+		// Enforce a structure for the document
+		/*var structure = {
+			link: "head",
+			base: "head"
+		};*/
+	
+		if ( !doc ) {
+			if ( typeof DOMDocument != "undefined" ){
+				doc = new DOMDocument();
+			}else if ( typeof document != "undefined" && document.implementation && document.implementation.createDocument ){
+				doc = document.implementation.createDocument("", "", null);
+			}else if ( typeof ActiveX != "undefined" ){
+				doc = new ActiveXObject("Msxml.DOMDocument");
+			}
+		} else {
+			doc = doc.ownerDocument ||
+				doc.getOwnerDocument && doc.getOwnerDocument() ||
+				doc;
+		}
+		
+		var elems = [],
+			documentElement = doc.documentElement || 
+			    doc.getDocumentElement && doc.getDocumentElement();
+				
+		// If we're dealing with an empty document then we
+		// need to pre-populate it with the HTML document structure
+		/*if ( !documentElement && doc.createElement ) (function(){
+		    //$log("HTMLtoDOM: adding structure... ");
+			var html = doc.createElement("html");
+			var head = doc.createElement("head");
+			head.appendChild( doc.createElement("title") );
+			html.appendChild( head );
+			html.appendChild( doc.createElement("body") );
+			doc.appendChild( html );
+			doc.documentElement = html;
+		})();*/
+		
+		// Find all the unique elements
+		/*if ( doc.getElementsByTagName ){
+			for ( var i in one ){
+			   one[ i ] = doc.getElementsByTagName( i )[0];
+            }
+		}*/
+		
+		// If we're working with a document, inject contents into
+		// the body element
+		var curParentNode;// = one.body;
+		
+		//$log("HTMLtoDOM: Parsing... ");
+		HTMLParser( html, {
+			start: function( tagName, attrs, unary ) {
+			    
+				var elem;
+		        //$log("HTMLtoDOM: createElement... " + tagName);
+				elem = doc.createElement( tagName );
+			
+				
+				for ( var attr in attrs ){
+		            //$log("HTMLtoDOM: setAttribute... " +  attrs[ attr ].name);
+					elem.setAttribute( attrs[ attr ].name, attrs[ attr ].value );
+				}
+				
+				if ( !doc.documentElement ){		            
+				    //$log("HTMLtoDOM: documentElement... " +  elem.nodeName);
+		            doc.documentElement = elem;
+			        doc.appendChild( elem );
+				}
+				
+				else if ( curParentNode && curParentNode.appendChild ){
+		            //$log("HTMLtoDOM: curParentNode.appendChild... " +  curParentNode.nodeName + " -> " +elem.nodeName);
+					curParentNode.appendChild( elem );
+				}
+					
+				if ( !unary ) {
+				    //$log("start : push into elems[] " + tagName);
+					elems.push( elem );
+					curParentNode = elem;
+				}
+			},
+			end: function( tag ) {
+			    //$log(tag + " : elems.lengths : "+elems.length);
+			    elems.length -= 1;
+				
+				// Init the new parentNode
+				curParentNode = elems[ elems.length - 1 ];
+
+			},
+			chars: function( text ) {
+				curParentNode.appendChild( doc.createTextNode( text ) );
+			},
+			comment: function( text ) {
+				curParentNode.appendChild( doc.createComment( text ) );
+			}
+		});
+				
+        //$log("HTMLtoDOM: doc... " + doc);
+		return doc;
+	};
+
+	function makeMap(str){
+		var obj = {}, items = str.split(",");
+		for ( var i = 0; i < items.length; i++ )
+			obj[ items[i] ] = true;
+		return obj;
+	};
+	
+})( );