envjs19 0.3.8.20101029121421

data/src/html/script.js

@@ -0,0 +1,122 @@
+$debug("Defining HTMLScriptElement");
+/* 
+* HTMLScriptElement - DOM Level 2
+*/
+var HTMLScriptElement = function(ownerDocument) {
+    this.HTMLElement = HTMLElement;
+    this.HTMLElement(ownerDocument);
+};
+HTMLScriptElement.prototype = new HTMLElement;
+__extend__(HTMLScriptElement.prototype, {
+    setAttribute: function(name,value) {
+      var result = HTMLElement.prototype.setAttribute.apply(this,arguments);
+      // print("set src",this,this.executed);
+      if (name === "src" && !this.executed && value && !value.match(/^\s*$/)) {
+        var pn = this;
+        while(pn.parentNode) {
+          pn = pn.parentNode;
+        }
+        if(pn === this.ownerDocument) { 
+          this.executed = true;
+          var $env = this.ownerDocument._parentWindow.$envx;
+          // print("on src change");
+          $env.loadLocalScript(this);
+        }
+      }
+      return result;
+    },
+
+    appendChild: function(node,ref) {
+      var result = HTMLElement.prototype.appendChild.apply(this,arguments);
+      // print("check",this,this.ownerDocument.in_inner_html);
+      if (!this.executed) {
+          var pn = this;
+          while(pn.parentNode) {
+            pn = pn.parentNode;
+          }
+          if(pn === this.ownerDocument) { 
+            var text = this.text;
+            // print("T:", text);
+            if (text && !text.match(/^\s*$/)) {
+              this.executed = true;
+              var $env = this.ownerDocument._parentWindow.$envx;
+              // print("on text change");
+              $env.loadInlineScript(this);
+            }
+          }
+      }
+      return result;
+    },
+
+    get text(){
+        // text of script is in a child node of the element
+        // scripts with < operator must be in a CDATA node
+        for (var i=0; i<this.childNodes.length; i++) {
+            if (this.childNodes[i].nodeType == DOMNode.CDATA_SECTION_NODE) {
+                return this.childNodes[i].nodeValue;
+            }
+        } 
+        // otherwise there will be a text node containing the script
+        if (this.childNodes[0] && this.childNodes[0].nodeType == DOMNode.TEXT_NODE) {
+            return this.childNodes[0].nodeValue;
+ 		}
+        return this.nodeValue;
+
+    },
+    set text(value){
+      while (this.firstChild) {
+        this.removeChild(this.firstChild);
+      }
+      this.appendChild(this.ownerDocument.createTextNode(value));
+    },
+    get htmlFor(){
+        return this.getAttribute('for');
+    },
+    set htmlFor(value){
+        this.setAttribute('for',value);
+    },
+    get event(){
+        return this.getAttribute('event');
+    },
+    set event(value){
+        this.setAttribute('event',value);
+    },
+    get charset(){
+        return this.getAttribute('charset');
+    },
+    set charset(value){
+        this.setAttribute('charset',value);
+    },
+    get defer(){
+        return this.getAttribute('defer');
+    },
+    set defer(value){
+        this.setAttribute('defer',value);
+    },
+    get src(){
+        return this.getAttribute('src');
+    },
+    set src(value){
+        this.setAttribute('src',value);
+    },
+    get type(){
+        return this.getAttribute('type');
+    },
+    set type(value){
+        this.setAttribute('type',value);
+    },
+    onload: function(event){
+        return __eval__(this.getAttribute('onload')||'', this);
+    },
+    onerror: function(event){
+        return __eval__(this.getAttribute('onerror')||'', this);
+    }
+});
+
+// $w.HTMLScriptElement = HTMLScriptElement;
+
+// Local Variables:
+// espresso-indent-level:4
+// c-basic-offset:4
+// tab-width:4
+// End:

data/src/html/select.js

@@ -0,0 +1,132 @@
+$debug("Defining HTMLSelectElement");
+/*
+* HTMLSelectElement - DOM Level 2
+*/
+var HTMLSelectElement = function(ownerDocument) {
+    this.HTMLTypeValueInputs = HTMLTypeValueInputs;
+    this.HTMLTypeValueInputs(ownerDocument);
+
+    this._oldIndex = -1;
+};
+HTMLSelectElement.prototype = new HTMLTypeValueInputs;
+__extend__(HTMLSelectElement.prototype, inputElements_dataProperties);
+__extend__(HTMLButtonElement.prototype, inputElements_size);
+__extend__(HTMLSelectElement.prototype, inputElements_onchange);
+__extend__(HTMLSelectElement.prototype, inputElements_focusEvents);
+__extend__(HTMLSelectElement.prototype, {
+    setAttributeNS : function(namespaceURI, qualifiedName, value) {
+        if (namespaceURI) {
+            throw new Error("unexpected namespaceURI");
+        }
+        this.setAttribute(qualifiedName, value);
+    },
+    getAttributeNS : function(namespaceURI, qualifiedName) {
+        if (namespaceURI) {
+            throw new Error("unexpected namespaceURI");
+        }
+        return this.getAttribute(qualifiedName);
+    },
+    setAttribute: function(name, value){
+        // This is a workaround for now for copying nodes in 
+        if (name === "type") {
+            if (!this.ownerDocument._performingImportNodeOperation) {
+                throw new Error("cannot set readonly attribute: "+name);
+            }
+        } else if (name === "multiple") {
+            HTMLInputCommon.prototype.
+                setAttribute.call(this, "type", value ? "select-multiple" : "select-one");
+            HTMLInputCommon.prototype.setAttribute.call(this, "multiple", !!value);
+        } else if (name === "value") {
+            var options = this.options,
+                i, index;
+            for (i=0; i<options.length; i++) {
+                if (options[i].value == value) {
+                    index = i;
+                    break;
+                }
+            }
+            if (index !== undefined) {
+                HTMLInputCommon.prototype.setAttribute.call(this, "value", value);
+                this.selectedIndex = index;
+
+                var event = this.ownerDocument.createEvent();
+                event.initEvent("change");
+                this.dispatchEvent( event );
+            }
+        } else {
+            HTMLInputCommon.prototype.setAttribute.apply(this, arguments);
+        }
+    },
+    getAttribute: function(name){
+        if (name === "type") {
+            return HTMLInputCommon.prototype.getAttribute.apply(this, arguments) || this.multple ? "select-multiple" : "select-one";
+        } else if (name === "value") {
+            var value = HTMLInputCommon.prototype.getAttribute.apply(this, arguments);
+            if (value === undefined || value === null) {
+                var index = this.selectedIndex;
+                return (index != -1) ? this.options[index].value :
+                    ( this.multiple ? "" :
+                      ( this.options[0] ? this.options[0].value : "" ) );
+            } else {
+                return value;
+            }
+        } else {
+            return HTMLInputCommon.prototype.getAttribute.apply(this, arguments);
+        }
+    },
+    // over-ride the value setter in HTMLTypeValueInputs
+    set value(newValue) {
+        this.setAttribute("value",newValue);
+    },
+    get value() {
+        return this.getAttribute("value");
+    },
+    get length(){
+        return this.options.length;
+    },
+    get multiple(){
+        return this.getAttribute('multiple');
+    },
+    set multiple(value){
+        this.setAttribute('multiple',value);
+    },
+    get options(){
+        return this.getElementsByTagName('option');
+    },
+    get selectedIndex(){
+        var options = this.options;
+        for(var i=0;i<options.length;i++){
+            if(options[i].selected){
+                return i;
+            }
+        };
+        return -1;
+    },
+    
+    set selectedIndex(value) {
+        var i;
+        for (i=0; i<this.options.length; i++) {
+            this.options[i].selected = this.multiple ?
+                (i == Number(value) || this.options[i].selected) :
+                (i == Number(value));
+        }
+    },
+    get type(){
+        return this.getAttribute('type');
+    },
+
+    add : function(){
+        __add__(this);
+    },
+    remove : function(){
+        __remove__(this);
+    }
+});
+
+// $w.HTMLSelectElement = HTMLSelectElement;
+
+// Local Variables:
+// espresso-indent-level:4
+// c-basic-offset:4
+// tab-width:4
+// End:

data/src/html/style.js

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

data/src/html/table.js

@@ -0,0 +1,199 @@
+$debug("Defining HTMLTableElement");
+/* 
+* HTMLTableElement - DOM Level 2
+* Implementation Provided by Steven Wood
+*/
+var HTMLTableElement = function(ownerDocument) {
+    this.HTMLElement = HTMLElement;
+    this.HTMLElement(ownerDocument);
+
+};
+
+HTMLTableElement.prototype = new HTMLElement;
+__extend__(HTMLTableElement.prototype, {
+    
+        get tFoot() { 
+        //tFoot returns the table footer.
+        return this.getElementsByTagName("tfoot")[0];
+    },
+    
+    createTFoot : function () {
+        var tFoot = this.tFoot;
+       
+        if (!tFoot) {
+            tFoot = this.ownerDocument.createElement("tfoot");
+            this.appendChild(tFoot);
+        }
+        
+        return tFoot;
+    },
+    
+    deleteTFoot : function () {
+        var foot = this.tFoot;
+        if (foot) {
+            foot.parentNode.removeChild(foot);
+        }
+    },
+    
+    get tHead() { 
+        //tHead returns the table head.
+        return this.getElementsByTagName("thead")[0];
+    },
+    
+    createTHead : function () {
+        var tHead = this.tHead;
+       
+        if (!tHead) {
+            tHead = this.ownerDocument.createElement("thead");
+            this.insertBefore(tHead, this.firstChild);
+        }
+        
+        return tHead;
+    },
+    
+    deleteTHead : function () {
+        var head = this.tHead;
+        if (head) {
+            head.parentNode.removeChild(head);
+        }
+    },
+ 
+    appendChild : function (child) {
+        
+        var tagName;
+        if(child&&child.nodeType==DOMNode.ELEMENT_NODE){
+            tagName = child.tagName.toLowerCase();
+            if (tagName === "tr") {
+                // need an implcit <tbody> to contain this...
+                if (!this.currentBody) {
+                    this.currentBody = this.ownerDocument.createElement("tbody");
+                
+                    DOMNode.prototype.appendChild.apply(this, [this.currentBody]);
+                }
+              
+                return this.currentBody.appendChild(child); 
+       
+            } else if (tagName === "tbody" || tagName === "tfoot" && this.currentBody) {
+                this.currentBody = child;
+                return DOMNode.prototype.appendChild.apply(this, arguments);  
+                
+            } else {
+                return DOMNode.prototype.appendChild.apply(this, arguments);
+            }
+        }else{
+            //tables can still have text node from white space
+            return DOMNode.prototype.appendChild.apply(this, arguments);
+        }
+    },
+     
+    get tBodies() {
+        return new HTMLCollection(this.getElementsByTagName("tbody"));
+        
+    },
+    
+    get rows() {
+        return new HTMLCollection(this.getElementsByTagName("tr"));
+    },
+    
+    insertRow : function (idx) {
+        if (idx === undefined) {
+            throw new Error("Index omitted in call to HTMLTableElement.insertRow ");
+        }
+        
+        var rows = this.rows, 
+            numRows = rows.length,
+            node,
+            inserted, 
+            lastRow;
+        
+        if (idx > numRows) {
+            throw new Error("Index > rows.length in call to HTMLTableElement.insertRow");
+        }
+        
+        var inserted = this.ownerDocument.createElement("tr");
+        // If index is -1 or equal to the number of rows, 
+        // the row is appended as the last row. If index is omitted 
+        // or greater than the number of rows, an error will result
+        if (idx === -1 || idx === numRows) {
+            this.appendChild(inserted);
+        } else {
+            rows[idx].parentNode.insertBefore(inserted, rows[idx]);
+        }
+
+        return inserted;
+    },
+    
+    deleteRow : function (idx) {
+        var elem = this.rows[idx];
+        elem.parentNode.removeChild(elem);
+    },
+    
+    get summary() {
+        return this.getAttribute("summary");
+    },
+    
+    set summary(summary) {
+        this.setAttribute("summary", summary);
+    },
+    
+    get align() {
+        return this.getAttribute("align");
+    },
+    
+    set align(align) {
+        this.setAttribute("align", align);
+    },
+    
+     
+    get bgColor() {
+        return this.getAttribute("bgColor");
+    },
+    
+    set bgColor(bgColor) {
+        return this.setAttribute("bgColor", bgColor);
+    },
+   
+    get cellPadding() {
+        return this.getAttribute("cellPadding");
+    },
+    
+    set cellPadding(cellPadding) {
+        return this.setAttribute("cellPadding", cellPadding);
+    },
+    
+    
+    get cellSpacing() {
+        return this.getAttribute("cellSpacing");
+    },
+    
+    set cellSpacing(cellSpacing) {
+        this.setAttribute("cellSpacing", cellSpacing);
+    },
+
+    get frame() {
+        return this.getAttribute("frame");
+    },
+    
+    set frame(frame) { 
+        this.setAttribute("frame", frame);
+    },
+    
+    get rules() {
+        return this.getAttribute("rules");
+    }, 
+    
+    set rules(rules) {
+        this.setAttribute("rules", rules);
+    }, 
+    
+    get width() {
+        return this.getAttribute("width");
+    },
+    
+    set width(width) {
+        this.setAttribute("width", width);
+    }
+    
+});
+
+// $w.HTMLTableElement = HTMLTableElement;