envjs19 0.3.8.20101029121421

data/src/dom/exception.js

@@ -0,0 +1,28 @@
+/**
+ * @class  DOMException - raised when an operation is impossible to perform
+ * @author Jon van Noort (jon@webarcana.com.au)
+ * @param  code : int - the exception code (one of the DOMException constants)
+ */
+var DOMException = function(code) {
+  this.code = code;
+};
+
+// DOMException constants
+// Introduced in DOM Level 1:
+DOMException.INDEX_SIZE_ERR                 = 1;
+DOMException.DOMSTRING_SIZE_ERR             = 2;
+DOMException.HIERARCHY_REQUEST_ERR          = 3;
+DOMException.WRONG_DOCUMENT_ERR             = 4;
+DOMException.INVALID_CHARACTER_ERR          = 5;
+DOMException.NO_DATA_ALLOWED_ERR            = 6;
+DOMException.NO_MODIFICATION_ALLOWED_ERR    = 7;
+DOMException.NOT_FOUND_ERR                  = 8;
+DOMException.NOT_SUPPORTED_ERR              = 9;
+DOMException.INUSE_ATTRIBUTE_ERR            = 10;
+
+// Introduced in DOM Level 2:
+DOMException.INVALID_STATE_ERR              = 11;
+DOMException.SYNTAX_ERR                     = 12;
+DOMException.INVALID_MODIFICATION_ERR       = 13;
+DOMException.NAMESPACE_ERR                  = 14;
+DOMException.INVALID_ACCESS_ERR             = 15;

data/src/dom/fragment.js

@@ -0,0 +1,37 @@
+$debug("Defining DocumentFragment");
+/* 
+* DocumentFragment - DOM Level 2
+*/
+/**
+ * @class  DOMDocumentFragment - DocumentFragment is a "lightweight" or "minimal" Document object.
+ * @extends DOMNode
+ * @author Jon van Noort (jon@webarcana.com.au) and David Joham (djoham@yahoo.com)
+ * @param  ownerDocument : DOMDocument - The Document object associated with this node.
+ */
+var DOMDocumentFragment = function(ownerDocument) {
+  this.DOMNode = DOMNode;
+  this.DOMNode(ownerDocument);
+  this.nodeName  = "#document-fragment";
+};
+DOMDocumentFragment.prototype = new DOMNode;
+__extend__(DOMDocumentFragment.prototype,{
+    get nodeType(){
+        return DOMNode.DOCUMENT_FRAGMENT_NODE;
+    },
+    get xml(){
+        var xml = "",
+            count = this.childNodes.length;
+        
+        // create string concatenating the serialized ChildNodes
+        for (var i = 0; i < count; i++) {
+            xml += this.childNodes.item(i).xml;
+        }
+        
+        return xml;
+    },
+    toString : function(){
+        return "DocumentFragment #"+this._id;
+    }
+});
+
+// $w.DocumentFragment = DOMDocumentFragment;

data/src/dom/implementation.js

@@ -0,0 +1,140 @@
+//DOMImplementation
+$debug("Defining DOMImplementation");
+/**
+ * @class  DOMImplementation - provides a number of methods for performing operations
+ *   that are independent of any particular instance of the document object model.
+ *
+ * @author Jon van Noort (jon@webarcana.com.au)
+ */
+var DOMImplementation = function() {
+    this.preserveWhiteSpace = false;  // by default, ignore whitespace
+    this.namespaceAware = true;       // by default, handle namespaces
+    this.errorChecking  = true;       // by default, test for exceptions
+};
+
+__extend__(DOMImplementation.prototype,{
+    // @param  feature : string - The package name of the feature to test.
+    //      the legal only values are "XML" and "CORE" (case-insensitive).
+    // @param  version : string - This is the version number of the package
+    //       name to test. In Level 1, this is the string "1.0".*
+    // @return : boolean
+    hasFeature : function(feature, version) {
+        var ret = false;
+        if (feature.toLowerCase() == "xml") {
+            ret = (!version || (version == "1.0") || (version == "2.0"));
+        }
+        else if (feature.toLowerCase() == "core") {
+            ret = (!version || (version == "2.0"));
+        }
+        else if (feature == "http://www.w3.org/TR/SVG11/feature#BasicStructure") {
+            ret = (version == "1.1");
+        }
+        return ret;
+    },
+    createDocumentType : function(qname, publicid, systemid){
+        return new DOMDocumentType();
+    },
+    createDocument : function(nsuri, qname, doctype){
+        //TODO - this currently returns an empty doc
+        //but needs to handle the args
+        return new DOMDocument(this, null);
+    },
+    createHTMLDocument : function(title){
+        // N.B. explict window on purpose ...
+        var doc = new HTMLDocument(this, window, "");
+        var html = doc.createElement("html"); doc.appendChild(html);
+        var head = doc.createElement("head"); html.appendChild(head);
+        var body = doc.createElement("body"); html.appendChild(body);
+        var t = doc.createElement("title"); head.appendChild(t);
+        if( title) {
+            t.appendChild(doc.createTextNode(title));
+        }
+        return doc;
+    },
+    translateErrCode : function(code) {
+        //convert DOMException Code to human readable error message;
+      var msg = "";
+
+      switch (code) {
+        case DOMException.INDEX_SIZE_ERR :                // 1
+           msg = "INDEX_SIZE_ERR: Index out of bounds";
+           break;
+
+        case DOMException.DOMSTRING_SIZE_ERR :            // 2
+           msg = "DOMSTRING_SIZE_ERR: The resulting string is too long to fit in a DOMString";
+           break;
+
+        case DOMException.HIERARCHY_REQUEST_ERR :         // 3
+           msg = "HIERARCHY_REQUEST_ERR: The Node can not be inserted at this location";
+           break;
+
+        case DOMException.WRONG_DOCUMENT_ERR :            // 4
+           msg = "WRONG_DOCUMENT_ERR: The source and the destination Documents are not the same";
+           break;
+
+        case DOMException.INVALID_CHARACTER_ERR :         // 5
+           msg = "INVALID_CHARACTER_ERR: The string contains an invalid character";
+           break;
+
+        case DOMException.NO_DATA_ALLOWED_ERR :           // 6
+           msg = "NO_DATA_ALLOWED_ERR: This Node / NodeList does not support data";
+           break;
+
+        case DOMException.NO_MODIFICATION_ALLOWED_ERR :   // 7
+           msg = "NO_MODIFICATION_ALLOWED_ERR: This object cannot be modified";
+           break;
+
+        case DOMException.NOT_FOUND_ERR :                 // 8
+           msg = "NOT_FOUND_ERR: The item cannot be found";
+           break;
+
+        case DOMException.NOT_SUPPORTED_ERR :             // 9
+           msg = "NOT_SUPPORTED_ERR: This implementation does not support function";
+           break;
+
+        case DOMException.INUSE_ATTRIBUTE_ERR :           // 10
+           msg = "INUSE_ATTRIBUTE_ERR: The Attribute has already been assigned to another Element";
+           break;
+
+        // Introduced in DOM Level 2:
+        case DOMException.INVALID_STATE_ERR :             // 11
+           msg = "INVALID_STATE_ERR: The object is no longer usable";
+           break;
+
+        case DOMException.SYNTAX_ERR :                    // 12
+           msg = "SYNTAX_ERR: Syntax error";
+           break;
+
+        case DOMException.INVALID_MODIFICATION_ERR :      // 13
+           msg = "INVALID_MODIFICATION_ERR: Cannot change the type of the object";
+           break;
+
+        case DOMException.NAMESPACE_ERR :                 // 14
+           msg = "NAMESPACE_ERR: The namespace declaration is incorrect";
+           break;
+
+        case DOMException.INVALID_ACCESS_ERR :            // 15
+           msg = "INVALID_ACCESS_ERR: The object does not support this function";
+           break;
+
+        default :
+           msg = "UNKNOWN: Unknown Exception Code ("+ code +")";
+      }
+
+      return msg;
+    }
+});
+
+
+if(false){
+$debug("Initializing document.implementation");
+var $implementation =  new DOMImplementation();
+// $implementation.namespaceAware = false;
+$implementation.errorChecking = false;
+}
+    
+// Local Variables:
+// espresso-indent-level:4
+// c-basic-offset:4
+// tab-width:4
+// End:

data/src/dom/instruction.js

@@ -0,0 +1,51 @@
+$debug("Defining ProcessingInstruction");
+/*
+* ProcessingInstruction - DOM Level 2
+*/
+/**
+ * @class  DOMProcessingInstruction - The ProcessingInstruction interface represents a "processing instruction",
+ *   used in XML as a way to keep processor-specific information in the text of the document
+ * @extends DOMNode
+ * @author Jon van Noort (jon@webarcana.com.au)
+ * @param  ownerDocument : DOMDocument - The Document object associated with this node.
+ */
+var DOMProcessingInstruction = function(ownerDocument) {
+  this.DOMNode  = DOMNode;
+  this.DOMNode(ownerDocument);
+};
+DOMProcessingInstruction.prototype = new DOMNode;
+__extend__(DOMProcessingInstruction.prototype, {
+    get data(){
+        return this.nodeValue;
+    },
+    set data(data){
+        // throw Exception if DOMNode is readonly
+        if (__ownerDocument__(this).errorChecking && this._readonly) {
+            throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+        }
+        this.nodeValue = data;
+    },
+    get target(){
+      // The target of this processing instruction.
+      // XML defines this as being the first token following the markup that begins the processing instruction.
+      // The content of this processing instruction.
+        return this.nodeName;
+    },
+    set target(value){
+      // The target of this processing instruction.
+      // XML defines this as being the first token following the markup that begins the processing instruction.
+      // The content of this processing instruction.
+        this.nodeName = value;
+    },
+    get nodeType(){
+        return DOMNode.PROCESSING_INSTRUCTION_NODE;
+    },
+    get xml(){
+        return "<?" + this.nodeName +" "+ this.nodeValue + " ?>";
+    },
+    toString : function(){
+        return "ProcessingInstruction #"+this._id;
+    }
+});
+
+// $w.ProcessesingInstruction = DOMProcessingInstruction;

data/src/dom/namednodemap.js

@@ -0,0 +1,374 @@
+/**
+ * @class  DOMNamedNodeMap - used to represent collections of nodes that can be accessed by name
+ *  typically a set of Element attributes
+ *
+ * @extends DOMNodeList - note W3C spec says that this is not the case,
+ *   but we need an item() method identicle to DOMNodeList's, so why not?
+ * @author Jon van Noort (jon@webarcana.com.au)
+ * @param  ownerDocument : DOMDocument - the ownerDocument
+ * @param  parentNode    : DOMNode - the node that the DOMNamedNodeMap is attached to (or null)
+ */
+var DOMNamedNodeMap = function(ownerDocument, parentNode) {
+    //$log("\t\tcreating dom namednodemap");
+    this.DOMNodeList = DOMNodeList;
+    this.DOMNodeList(ownerDocument, parentNode);
+    __setArray__(this, []);
+};
+DOMNamedNodeMap.prototype = new DOMNodeList;
+__extend__(DOMNamedNodeMap.prototype, {
+    add: function(name){
+        this[this.length] = name;
+    },
+    getNamedItem : function(name) {
+        var ret = null;
+        
+        // test that Named Node exists
+        var itemIndex = __findNamedItemIndex__(this, name);
+        
+        if (itemIndex > -1) {                          // found it!
+            ret = this[itemIndex];                // return NamedNode
+        }
+        
+        return ret;                                    // if node is not found, default value null is returned
+    },
+    setNamedItem : function(arg) {
+      // test for exceptions
+      if (__ownerDocument__(this).implementation.errorChecking) {
+            // throw Exception if arg was not created by this Document
+            if (this.ownerDocument != arg.ownerDocument) {
+              throw(new DOMException(DOMException.WRONG_DOCUMENT_ERR));
+            }
+        
+            // throw Exception if DOMNamedNodeMap is readonly
+            if (this._readonly || (this.parentNode && this.parentNode._readonly)) {
+              throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+            }
+        
+            // throw Exception if arg is already an attribute of another Element object
+            if (arg.ownerElement && (arg.ownerElement != this.parentNode)) {
+              throw(new DOMException(DOMException.INUSE_ATTRIBUTE_ERR));
+            }
+      }
+    
+      // get item index
+      var itemIndex = __findNamedItemIndex__(this, arg.name);
+      var ret = null;
+    
+      if (itemIndex > -1) {                          // found it!
+            ret = this[itemIndex];                // use existing Attribute
+        
+            // throw Exception if DOMAttr is readonly
+            if (__ownerDocument__(this).implementation.errorChecking && ret._readonly) {
+              throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+            } else {
+              this[itemIndex] = arg;                // over-write existing NamedNode
+              this[arg.name.toLowerCase()] = arg;
+            }
+      } else {
+            // add new NamedNode
+            Array.prototype.push.apply(this, [arg]);
+            this[arg.name.toLowerCase()] = arg;
+      }
+    
+      arg.ownerElement = this.parentNode;            // update ownerElement
+    
+      return ret;                                    // return old node or null
+    },
+    removeNamedItem : function(name) {
+          var ret = null;
+          // test for exceptions
+          // throw Exception if DOMNamedNodeMap is readonly
+          if (__ownerDocument__(this).implementation.errorChecking && 
+                (this._readonly || (this.parentNode && this.parentNode._readonly))) {
+              throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+          }
+        
+          // get item index
+          var itemIndex = __findNamedItemIndex__(this, name);
+        
+          // throw Exception if there is no node named name in this map
+          if (__ownerDocument__(this).implementation.errorChecking && (itemIndex < 0)) {
+            throw(new DOMException(DOMException.NOT_FOUND_ERR));
+          }
+        
+          // get Node
+          var oldNode = this[itemIndex];
+          //this[oldNode.name] = undefined;
+        
+          // throw Exception if Node is readonly
+          if (__ownerDocument__(this).implementation.errorChecking && oldNode._readonly) {
+            throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+          }
+        
+          // return removed node
+          return __removeChild__(this, itemIndex);
+    },
+    getNamedItemNS : function(namespaceURI, localName) {
+          var ret = null;
+        
+          // test that Named Node exists
+          var itemIndex = __findNamedItemNSIndex__(this, namespaceURI, localName);
+        
+          if (itemIndex > -1) {                          // found it!
+            ret = this[itemIndex];                // return NamedNode
+          }
+        
+          return ret;                                    // if node is not found, default value null is returned
+    },
+    setNamedItemNS : function(arg) {
+          // test for exceptions
+          if (__ownerDocument__(this).implementation.errorChecking) {
+            // throw Exception if DOMNamedNodeMap is readonly
+            if (this._readonly || (this.parentNode && this.parentNode._readonly)) {
+              throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+            }
+        
+            // throw Exception if arg was not created by this Document
+            if (__ownerDocument__(this) != __ownerDocument__(arg)) {
+              throw(new DOMException(DOMException.WRONG_DOCUMENT_ERR));
+            }
+        
+            // throw Exception if arg is already an attribute of another Element object
+            if (arg.ownerElement && (arg.ownerElement != this.parentNode)) {
+              throw(new DOMException(DOMException.INUSE_ATTRIBUTE_ERR));
+            }
+          }
+        
+          // get item index
+          var itemIndex = __findNamedItemNSIndex__(this, arg.namespaceURI, arg.localName);
+          var ret = null;
+        
+          if (itemIndex > -1) {                          // found it!
+            ret = this[itemIndex];                // use existing Attribute
+            // throw Exception if DOMAttr is readonly
+            if (__ownerDocument__(this).implementation.errorChecking && ret._readonly) {
+              throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+            } else {
+              this[itemIndex] = arg;                // over-write existing NamedNode
+              this[arg.name.toLowerCase()] = arg;
+            }
+          }else {
+            // add new NamedNode
+            Array.prototype.push.apply(this, [arg]);
+            this[arg.name.toLowerCase()] = arg;
+          }
+          arg.ownerElement = this.parentNode;
+        
+        
+          return ret;                                    // return old node or null
+    },
+    removeNamedItemNS : function(namespaceURI, localName) {
+          var ret = null;
+        
+          // test for exceptions
+          // throw Exception if DOMNamedNodeMap is readonly
+          if (__ownerDocument__(this).implementation.errorChecking && (this._readonly || (this.parentNode && this.parentNode._readonly))) {
+            throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+          }
+        
+          // get item index
+          var itemIndex = __findNamedItemNSIndex__(this, namespaceURI, localName);
+        
+          // throw Exception if there is no matching node in this map
+          if (__ownerDocument__(this).implementation.errorChecking && (itemIndex < 0)) {
+            throw(new DOMException(DOMException.NOT_FOUND_ERR));
+          }
+        
+          // get Node
+          var oldNode = this[itemIndex];
+        
+          // throw Exception if Node is readonly
+          if (__ownerDocument__(this).implementation.errorChecking && oldNode._readonly) {
+            throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+          }
+        
+          return __removeChild__(this, itemIndex);             // return removed node
+    },
+    get xml() {
+          var ret = "";
+        
+          // create string containing concatenation of all (but last) Attribute string values (separated by spaces)
+          for (var i=0; i < this.length -1; i++) {
+            ret += this[i].xml +" ";
+          }
+        
+          // add last Attribute to string (without trailing space)
+          if (this.length > 0) {
+            ret += this[this.length -1].xml;
+          }
+
+          return ret;
+    }
+
+});
+
+/**
+ * @method DOMNamedNodeMap._findNamedItemIndex - find the item index of the node with the specified name
+ *
+ * @author Jon van Noort (jon@webarcana.com.au)
+ * @param  name : string - the name of the required node
+ * @return : int
+ */
+var __findNamedItemIndex__ = function(namednodemap, name) {
+  var ret = -1;
+
+  // loop through all nodes
+  for (var i=0; i<namednodemap.length; i++) {
+    // compare name to each node's nodeName
+    if(namednodemap.isnsmap){
+        if (namednodemap[i].localName.toLowerCase() == name.toLowerCase()) {         // found it!
+          ret = i;
+          break;
+        }
+    }else{
+        if (namednodemap[i].name.toLowerCase() == name.toLowerCase()) {         // found it!
+          ret = i;
+          break;
+        }
+    }
+  }
+
+  return ret;                                    // if node is not found, default value -1 is returned
+};
+
+/**
+ * @method DOMNamedNodeMap._findNamedItemNSIndex - find the item index of the node with the specified namespaceURI and localName
+ *
+ * @author Jon van Noort (jon@webarcana.com.au)
+ * @param  namespaceURI : string - the namespace URI of the required node
+ * @param  localName    : string - the local name of the required node
+ * @return : int
+ */
+var __findNamedItemNSIndex__ = function(namednodemap, namespaceURI, localName) {
+  var ret = -1;
+
+  // test that localName is not null
+  if (localName) {
+    // loop through all nodes
+    for (var i=0; i<namednodemap.length; i++) {
+      // compare name to each node's namespaceURI and localName
+      if ((namednodemap[i].namespaceURI.toLowerCase() == namespaceURI.toLowerCase()) && 
+          (namednodemap[i].localName.toLowerCase() == localName.toLowerCase())) {
+        ret = i;                                 // found it!
+        break;
+      }
+    }
+  }
+
+  return ret;                                    // if node is not found, default value -1 is returned
+};
+
+/**
+ * @method DOMNamedNodeMap._hasAttribute - Returns true if specified node exists
+ *
+ * @author Jon van Noort (jon@webarcana.com.au)
+ * @param  name : string - the name of the required node
+ * @return : boolean
+ */
+var __hasAttribute__ = function(namednodemap, name) {
+  var ret = false;
+
+  // test that Named Node exists
+  var itemIndex = __findNamedItemIndex__(namednodemap, name);
+
+  if (itemIndex > -1) {                          // found it!
+    ret = true;                                  // return true
+  }
+
+  return ret;                                    // if node is not found, default value false is returned
+}
+
+/**
+ * @method DOMNamedNodeMap._hasAttributeNS - Returns true if specified node exists
+ *
+ * @author Jon van Noort (jon@webarcana.com.au)
+ * @param  namespaceURI : string - the namespace URI of the required node
+ * @param  localName    : string - the local name of the required node
+ * @return : boolean
+ */
+var __hasAttributeNS__ = function(namednodemap, namespaceURI, localName) {
+  var ret = false;
+
+  // test that Named Node exists
+  var itemIndex = __findNamedItemNSIndex__(namednodemap, namespaceURI, localName);
+
+  if (itemIndex > -1) {                          // found it!
+    ret = true;                                  // return true
+  }
+
+  return ret;                                    // if node is not found, default value false is returned
+}
+
+/**
+ * @method DOMNamedNodeMap._cloneNodes - Returns a NamedNodeMap containing clones of the Nodes in this NamedNodeMap
+ *
+ * @author Jon van Noort (jon@webarcana.com.au)
+ * @param  parentNode : DOMNode - the new parent of the cloned NodeList
+ * @param  isnsmap : bool - is this a DOMNamespaceNodeMap
+ * @return : DOMNamedNodeMap - NamedNodeMap containing clones of the Nodes in this DOMNamedNodeMap
+ */
+var __cloneNamedNodes__ = function(namednodemap, parentNode) {
+  var cloneNamedNodeMap = namednodemap.isnsmap?
+    new DOMNamespaceNodeMap(namednodemap.ownerDocument, parentNode):
+    new DOMNamedNodeMap(namednodemap.ownerDocument, parentNode);
+
+  // create list containing clones of all children
+  for (var i=0; i < namednodemap.length; i++) {
+      $debug("cloning node in named node map :" + namednodemap[i]);
+    __appendChild__(cloneNamedNodeMap, namednodemap[i].cloneNode(false));
+  }
+
+  return cloneNamedNodeMap;
+};
+
+
+/**
+ * @class  DOMNamespaceNodeMap - used to represent collections of namespace nodes that can be accessed by name
+ *  typically a set of Element attributes
+ *
+ * @extends DOMNamedNodeMap
+ *
+ * @author Jon van Noort (jon@webarcana.com.au)
+ *
+ * @param  ownerDocument : DOMDocument - the ownerDocument
+ * @param  parentNode    : DOMNode - the node that the DOMNamespaceNodeMap is attached to (or null)
+ */
+var DOMNamespaceNodeMap = function(ownerDocument, parentNode) {
+    //$log("\t\t\tcreating dom namespacednodemap");
+    this.DOMNamedNodeMap = DOMNamedNodeMap;
+    this.DOMNamedNodeMap(ownerDocument, parentNode);
+    __setArray__(this, []);
+    this.isnsmap = true;
+};
+DOMNamespaceNodeMap.prototype = new DOMNamedNodeMap;
+__extend__(DOMNamespaceNodeMap.prototype, {
+    get xml() {
+          var ret = "";
+        
+          // identify namespaces declared local to this Element (ie, not inherited)
+          for (var ind = 0; ind < this.length; ind++) {
+            // if namespace declaration does not exist in the containing node's, parentNode's namespaces
+            var ns = null;
+            try {
+                var ns = this.parentNode.parentNode._namespaces.
+                    getNamedItem(this[ind].localName);
+            }
+            catch (e) {
+                //breaking to prevent default namespace being inserted into return value
+                break;
+            }
+            if (!(ns && (""+ ns.nodeValue == ""+ this[ind].nodeValue))) {
+              // display the namespace declaration
+              ret += this[ind].xml +" ";
+            }
+          }
+
+          return ret;
+    }
+});
+
+// Local Variables:
+// espresso-indent-level:4
+// c-basic-offset:4
+// tab-width:4
+// End: